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   return scoped_ptr<AppSorting>();
 145 }
 146
 147 bool TestExtensionsBrowserClient::IsRunningInForcedAppMode() { return false; }
 148
 149 ApiActivityMonitor* TestExtensionsBrowserClient::GetApiActivityMonitor(
 150     BrowserContext* context) {
 151   return NULL;
 152 }
 153
 154 ExtensionSystemProvider*
 155 TestExtensionsBrowserClient::GetExtensionSystemFactory() {
 156   DCHECK(extension_system_factory_);
 157   return extension_system_factory_;
 158 }
 159
 160 void TestExtensionsBrowserClient::RegisterExtensionFunctions(
 161     ExtensionFunctionRegistry* registry) const {}
 162
 163 void TestExtensionsBrowserClient::RegisterMojoServices(
 164     content::RenderFrameHost* render_frame_host,
 165     const Extension* extension) const {
 166 }
 167
 168 scoped_ptr<RuntimeAPIDelegate>
 169 TestExtensionsBrowserClient::CreateRuntimeAPIDelegate(
 170     content::BrowserContext* context) const {
 171   return scoped_ptr<RuntimeAPIDelegate>(new TestRuntimeAPIDelegate());
 172 }
 173
 174 const ComponentExtensionResourceManager*
 175 TestExtensionsBrowserClient::GetComponentExtensionResourceManager() {
 176   return NULL;
 177 }
 178
 179 void TestExtensionsBrowserClient::BroadcastEventToRenderers(
 180     const std::string& event_name,
 181     scoped_ptr<base::ListValue> args) {
 182 }
 183
 184 net::NetLog* TestExtensionsBrowserClient::GetNetLog() {
 185   return NULL;
 186 }
 187
 188 ExtensionCache* TestExtensionsBrowserClient::GetExtensionCache() {
 189   return extension_cache_.get();
 190 }
 191
 192 bool TestExtensionsBrowserClient::IsBackgroundUpdateAllowed() {
 193   return true;
 194 }
 195
 196 bool TestExtensionsBrowserClient::IsMinBrowserVersionSupported(
 197     const std::string& min_version) {
 198   return true;
 199 }
 200
 201 }  // namespace extensions