src/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
  12 using content::BrowserContext;
  13
  14 namespace extensions {
  15
  16 TestExtensionsBrowserClient::TestExtensionsBrowserClient(
  17     BrowserContext* main_context)
  18     : main_context_(main_context),
  19       incognito_context_(NULL),
  20       process_manager_delegate_(NULL),
  21       extension_system_factory_(NULL) {
  22   DCHECK(main_context_);
  23   DCHECK(!main_context_->IsOffTheRecord());
  24 }
  25
  26 TestExtensionsBrowserClient::~TestExtensionsBrowserClient() {}
  27
  28 void TestExtensionsBrowserClient::SetIncognitoContext(BrowserContext* context) {
  29   // If a context is provided it must be off-the-record.
  30   DCHECK(!context || context->IsOffTheRecord());
  31   incognito_context_ = context;
  32 }
  33
  34 bool TestExtensionsBrowserClient::IsShuttingDown() { return false; }
  35
  36 bool TestExtensionsBrowserClient::AreExtensionsDisabled(
  37     const base::CommandLine& command_line,
  38     BrowserContext* context) {
  39   return false;
  40 }
  41
  42 bool TestExtensionsBrowserClient::IsValidContext(BrowserContext* context) {
  43   return context == main_context_ ||
  44          (incognito_context_ && context == incognito_context_);
  45 }
  46
  47 bool TestExtensionsBrowserClient::IsSameContext(BrowserContext* first,
  48                                                 BrowserContext* second) {
  49   DCHECK(first);
  50   DCHECK(second);
  51   return first == second ||
  52          (first == main_context_ && second == incognito_context_) ||
  53          (first == incognito_context_ && second == main_context_);
  54 }
  55
  56 bool TestExtensionsBrowserClient::HasOffTheRecordContext(
  57     BrowserContext* context) {
  58   return context == main_context_ && incognito_context_ != NULL;
  59 }
  60
  61 BrowserContext* TestExtensionsBrowserClient::GetOffTheRecordContext(
  62     BrowserContext* context) {
  63   if (context == main_context_)
  64     return incognito_context_;
  65   return NULL;
  66 }
  67
  68 BrowserContext* TestExtensionsBrowserClient::GetOriginalContext(
  69     BrowserContext* context) {
  70   return main_context_;
  71 }
  72
  73 bool TestExtensionsBrowserClient::IsGuestSession(
  74     BrowserContext* context) const {
  75   return false;
  76 }
  77
  78 bool TestExtensionsBrowserClient::IsExtensionIncognitoEnabled(
  79     const std::string& extension_id,
  80     content::BrowserContext* context) const {
  81   return false;
  82 }
  83
  84 bool TestExtensionsBrowserClient::CanExtensionCrossIncognito(
  85     const extensions::Extension* extension,
  86     content::BrowserContext* context) const {
  87   return false;
  88 }
  89
  90 net::URLRequestJob*
  91 TestExtensionsBrowserClient::MaybeCreateResourceBundleRequestJob(
  92     net::URLRequest* request,
  93     net::NetworkDelegate* network_delegate,
  94     const base::FilePath& directory_path,
  95     const std::string& content_security_policy,
  96     bool send_cors_header) {
  97   return NULL;
  98 }
  99
 100 bool TestExtensionsBrowserClient::AllowCrossRendererResourceLoad(
 101     net::URLRequest* request,
 102     bool is_incognito,
 103     const Extension* extension,
 104     InfoMap* extension_info_map) {
 105   return false;
 106 }
 107
 108 PrefService* TestExtensionsBrowserClient::GetPrefServiceForContext(
 109     BrowserContext* context) {
 110   return NULL;
 111 }
 112
 113 void TestExtensionsBrowserClient::GetEarlyExtensionPrefsObservers(
 114     content::BrowserContext* context,
 115     std::vector<ExtensionPrefsObserver*>* observers) const {}
 116
 117 ProcessManagerDelegate* TestExtensionsBrowserClient::GetProcessManagerDelegate()
 118     const {
 119   return process_manager_delegate_;
 120 }
 121
 122 scoped_ptr<ExtensionHostDelegate>
 123 TestExtensionsBrowserClient::CreateExtensionHostDelegate() {
 124   return scoped_ptr<ExtensionHostDelegate>();
 125 }
 126
 127 bool TestExtensionsBrowserClient::DidVersionUpdate(BrowserContext* context) {
 128   return false;
 129 }
 130
 131 void TestExtensionsBrowserClient::PermitExternalProtocolHandler() {
 132 }
 133
 134 scoped_ptr<AppSorting> TestExtensionsBrowserClient::CreateAppSorting() {
 135   return scoped_ptr<AppSorting>();
 136 }
 137
 138 bool TestExtensionsBrowserClient::IsRunningInForcedAppMode() { return false; }
 139
 140 ApiActivityMonitor* TestExtensionsBrowserClient::GetApiActivityMonitor(
 141     BrowserContext* context) {
 142   return NULL;
 143 }
 144
 145 ExtensionSystemProvider*
 146 TestExtensionsBrowserClient::GetExtensionSystemFactory() {
 147   DCHECK(extension_system_factory_);
 148   return extension_system_factory_;
 149 }
 150
 151 void TestExtensionsBrowserClient::RegisterExtensionFunctions(
 152     ExtensionFunctionRegistry* registry) const {}
 153
 154 scoped_ptr<RuntimeAPIDelegate>
 155 TestExtensionsBrowserClient::CreateRuntimeAPIDelegate(
 156     content::BrowserContext* context) const {
 157   return scoped_ptr<RuntimeAPIDelegate>(new TestRuntimeAPIDelegate());
 158 }
 159
 160 ComponentExtensionResourceManager*
 161 TestExtensionsBrowserClient::GetComponentExtensionResourceManager() {
 162   return NULL;
 163 }
 164
 165 void TestExtensionsBrowserClient::BroadcastEventToRenderers(
 166     const std::string& event_name,
 167     scoped_ptr<base::ListValue> args) {
 168 }
 169
 170 net::NetLog* TestExtensionsBrowserClient::GetNetLog() {
 171   return NULL;
 172 }
 173
 174 }  // namespace extensions