extensions/browser/test_extensions_browser_client.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/test_extensions_browser_client.h"
   6
   7 #include "content/public/browser/browser_context.h"
   8 #include "extensions/browser/app_sorting.h"
   9 #include "extensions/browser/extension_host_delegate.h"
  10 #include "extensions/browser/test_runtime_api_delegate.h"
  11 #include "extensions/browser/updater/null_extension_cache.h"
  12
  13 using content::BrowserContext;
  14
  15 namespace extensions {
  16
  17 TestExtensionsBrowserClient::TestExtensionsBrowserClient(
  18     BrowserContext* main_context)
  19     : main_context_(main_context),
  20       incognito_context_(NULL),
  21       process_manager_delegate_(NULL),
  22       extension_system_factory_(NULL),
  23       extension_cache_(new NullExtensionCache) {
  24   DCHECK(main_context_);
  25   DCHECK(!main_context_->IsOffTheRecord());
  26 }
  27
  28 TestExtensionsBrowserClient::~TestExtensionsBrowserClient() {}
  29
  30 void TestExtensionsBrowserClient::SetIncognitoContext(BrowserContext* context) {
  31   // If a context is provided it must be off-the-record.
  32   DCHECK(!context || context->IsOffTheRecord());
  33   incognito_context_ = context;
  34 }
  35
  36 bool TestExtensionsBrowserClient::IsShuttingDown() { return false; }
  37
  38 bool TestExtensionsBrowserClient::AreExtensionsDisabled(
  39     const base::CommandLine& command_line,
  40     BrowserContext* context) {
  41   return false;
  42 }
  43
  44 bool TestExtensionsBrowserClient::IsValidContext(BrowserContext* context) {
  45   return context == main_context_ ||
  46          (incognito_context_ && context == incognito_context_);
  47 }
  48
  49 bool TestExtensionsBrowserClient::IsSameContext(BrowserContext* first,
  50                                                 BrowserContext* second) {
  51   DCHECK(first);
  52   DCHECK(second);
  53   return first == second ||
  54          (first == main_context_ && second == incognito_context_) ||
  55          (first == incognito_context_ && second == main_context_);
  56 }
  57
  58 bool TestExtensionsBrowserClient::HasOffTheRecordContext(
  59     BrowserContext* context) {
  60   return context == main_context_ && incognito_context_ != NULL;
  61 }
  62
  63 BrowserContext* TestExtensionsBrowserClient::GetOffTheRecordContext(
  64     BrowserContext* context) {
  65   if (context == main_context_)
  66     return incognito_context_;
  67   return NULL;
  68 }
  69
  70 BrowserContext* TestExtensionsBrowserClient::GetOriginalContext(
  71     BrowserContext* context) {
  72   return main_context_;
  73 }
  74
  75 #if defined(OS_CHROMEOS)
  76 std::string TestExtensionsBrowserClient::GetUserIdHashFromContext(
  77     content::BrowserContext* context) {
  78   return "";
  79 }
  80 #endif
  81
  82 bool TestExtensionsBrowserClient::IsGuestSession(
  83     BrowserContext* context) const {
  84   return false;
  85 }
  86
  87 bool TestExtensionsBrowserClient::IsExtensionIncognitoEnabled(
  88     const std::string& extension_id,
  89     content::BrowserContext* context) const {
  90   return false;
  91 }
  92
  93 bool TestExtensionsBrowserClient::CanExtensionCrossIncognito(
  94     const extensions::Extension* extension,
  95     content::BrowserContext* context) const {
  96   return false;
  97 }
  98
  99 net::URLRequestJob*
 100 TestExtensionsBrowserClient::MaybeCreateResourceBundleRequestJob(
 101     net::URLRequest* request,
 102     net::NetworkDelegate* network_delegate,
 103     const base::FilePath& directory_path,
 104     const std::string& content_security_policy,
 105     bool send_cors_header) {
 106   return NULL;
 107 }
 108
 109 bool TestExtensionsBrowserClient::AllowCrossRendererResourceLoad(
 110     net::URLRequest* request,
 111     bool is_incognito,
 112     const Extension* extension,
 113     InfoMap* extension_info_map) {
 114   return false;
 115 }
 116
 117 PrefService* TestExtensionsBrowserClient::GetPrefServiceForContext(
 118     BrowserContext* context) {
 119   return NULL;
 120 }
 121
 122 void TestExtensionsBrowserClient::GetEarlyExtensionPrefsObservers(
 123     content::BrowserContext* context,
 124     std::vector<ExtensionPrefsObserver*>* observers) const {}
 125
 126 ProcessManagerDelegate* TestExtensionsBrowserClient::GetProcessManagerDelegate()
 127     const {
 128   return process_manager_delegate_;
 129 }
 130
 131 scoped_ptr<ExtensionHostDelegate>
 132 TestExtensionsBrowserClient::CreateExtensionHostDelegate() {
 133   return scoped_ptr<ExtensionHostDelegate>();
 134 }
 135
 136 bool TestExtensionsBrowserClient::DidVersionUpdate(BrowserContext* context) {
 137   return false;
 138 }
 139
 140 void TestExtensionsBrowserClient::PermitExternalProtocolHandler() {
 141 }
 142
 143 scoped_ptr<AppSorting> TestExtensionsBrowserClient::CreateAppSorting(
 144     content::BrowserContext* context) {
 145   return scoped_ptr<AppSorting>();
 146 }
 147
 148 bool TestExtensionsBrowserClient::IsRunningInForcedAppMode() { return false; }
 149
 150 ApiActivityMonitor* TestExtensionsBrowserClient::GetApiActivityMonitor(
 151     BrowserContext* context) {
 152   return NULL;
 153 }
 154
 155 ExtensionSystemProvider*
 156 TestExtensionsBrowserClient::GetExtensionSystemFactory() {
 157   DCHECK(extension_system_factory_);
 158   return extension_system_factory_;
 159 }
 160
 161 void TestExtensionsBrowserClient::RegisterExtensionFunctions(
 162     ExtensionFunctionRegistry* registry) const {}
 163
 164 void TestExtensionsBrowserClient::RegisterMojoServices(
 165     content::RenderFrameHost* render_frame_host,
 166     const Extension* extension) const {
 167 }
 168
 169 scoped_ptr<RuntimeAPIDelegate>
 170 TestExtensionsBrowserClient::CreateRuntimeAPIDelegate(
 171     content::BrowserContext* context) const {
 172   return scoped_ptr<RuntimeAPIDelegate>(new TestRuntimeAPIDelegate());
 173 }
 174
 175 const ComponentExtensionResourceManager*
 176 TestExtensionsBrowserClient::GetComponentExtensionResourceManager() {
 177   return NULL;
 178 }
 179
 180 void TestExtensionsBrowserClient::BroadcastEventToRenderers(
 181     events::HistogramValue histogram_value,
 182     const std::string& event_name,
 183     scoped_ptr<base::ListValue> args) {}
 184
 185 net::NetLog* TestExtensionsBrowserClient::GetNetLog() {
 186   return NULL;
 187 }
 188
 189 ExtensionCache* TestExtensionsBrowserClient::GetExtensionCache() {
 190   return extension_cache_.get();
 191 }
 192
 193 bool TestExtensionsBrowserClient::IsBackgroundUpdateAllowed() {
 194   return true;
 195 }
 196
 197 bool TestExtensionsBrowserClient::IsMinBrowserVersionSupported(
 198     const std::string& min_version) {
 199   return true;
 200 }
 201
 202 ExtensionWebContentsObserver*
 203 TestExtensionsBrowserClient::GetExtensionWebContentsObserver(
 204     content::WebContents* web_contents) {
 205   return nullptr;
 206 }
 207
 208 }  // namespace extensions