Revert 124817 - Take extensions out of Profile into a profile-keyed service, ExtensionSystem.

chrome/browser/profiles/profile_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/profiles/profile_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data_remover.h"
 #include "chrome/browser/chrome_plugin_service_filter.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
+#include "chrome/browser/extensions/component_loader.h"
+#include "chrome/browser/extensions/extension_devtools_manager.h"
+#include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_event_router.h"
+#include "chrome/browser/extensions/extension_info_map.h"
+#include "chrome/browser/extensions/extension_message_service.h"
+#include "chrome/browser/extensions/extension_navigation_observer.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
-#include "chrome/browser/extensions/extension_pref_value_map.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
-#include "chrome/browser/extensions/extension_system.h"
-#include "chrome/browser/extensions/extension_system_factory.h"
+#include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/geolocation/chrome_geolocation_permission_context.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/shortcuts_backend.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/instant/instant_controller.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/net_pref_observer.h"
@@ skipping 170 matching lines @@
   PasswordStoreX::RegisterUserPrefs(prefs);
 #endif
 }
 
 ProfileImpl::ProfileImpl(const FilePath& path,
                          Profile::Delegate* delegate)
     : path_(path),
       ALLOW_THIS_IN_INITIALIZER_LIST(visited_link_event_listener_(
           new VisitedLinkEventListener(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_data_(this)),
+      extension_devtools_manager_(NULL),
       host_content_settings_map_(NULL),
       history_service_created_(false),
       favicon_service_created_(false),
       created_web_data_service_(false),
       created_password_store_(false),
       start_time_(Time::Now()),
 #if defined(OS_WIN)
       checked_instant_promo_(false),
 #endif
       delegate_(delegate),
@@ skipping 177 matching lines @@
           host, &zoom_level);
       DCHECK(success);
       host_zoom_map->SetZoomLevel(host, zoom_level);
     }
   }
 
   registrar_.Add(this, content::NOTIFICATION_ZOOM_LEVEL_CHANGED,
                content::Source<HostZoomMap>(host_zoom_map));
 }
 
+void ProfileImpl::InitExtensions(bool extensions_enabled) {
+  if (user_script_master_ || extension_service_.get())
+    return;  // Already initialized.
+
+  const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(
+      switches::kEnableExtensionTimelineApi)) {
+    extension_devtools_manager_ = new ExtensionDevToolsManager(this);
+  }
+
+  // The ExtensionInfoMap needs to be created before the
+  // ExtensionProcessManager.
+  extension_info_map_ = new ExtensionInfoMap();
+  extension_process_manager_.reset(ExtensionProcessManager::Create(this));
+  extension_event_router_.reset(new ExtensionEventRouter(this));
+  extension_message_service_ = new ExtensionMessageService(this);
+  extension_navigation_observer_.reset(new ExtensionNavigationObserver(this));
+
+  ExtensionErrorReporter::Init(true);  // allow noisy errors.
+
+  user_script_master_ = new UserScriptMaster(this);
+
+  bool autoupdate_enabled = true;
+#if defined(OS_CHROMEOS)
+  if (!extensions_enabled)
+    autoupdate_enabled = false;
+  else
+    autoupdate_enabled = !command_line->HasSwitch(switches::kGuestSession);
+#endif
+  extension_service_.reset(new ExtensionService(
+      this,
+      CommandLine::ForCurrentProcess(),
+      GetPath().AppendASCII(ExtensionService::kInstallDirectoryName),
+      extension_prefs_.get(),
+      autoupdate_enabled,
+      extensions_enabled));
+
+  extension_service_->component_loader()->AddDefaultComponentExtensions();
+  if (command_line->HasSwitch(switches::kLoadComponentExtension)) {
+    CommandLine::StringType path_list = command_line->GetSwitchValueNative(
+        switches::kLoadComponentExtension);
+    StringTokenizerT<CommandLine::StringType,
+        CommandLine::StringType::const_iterator> t(path_list,
+                                                   FILE_PATH_LITERAL(","));
+    while (t.GetNext()) {
+      // Load the component extension manifest synchronously.
+      // Blocking the UI thread is acceptable here since
+      // this flag designated for developers.
+      base::ThreadRestrictions::ScopedAllowIO allow_io;
+      extension_service_->component_loader()->AddOrReplace(
+          FilePath(t.token()));
+    }
+  }
+  extension_service_->Init();
+
+  if (extensions_enabled) {
+    // Load any extensions specified with --load-extension.
+    // TODO(yoz): Seems like this should move into ExtensionService::Init.
+    if (command_line->HasSwitch(switches::kLoadExtension)) {
+      CommandLine::StringType path_list = command_line->GetSwitchValueNative(
+          switches::kLoadExtension);
+      StringTokenizerT<CommandLine::StringType,
+          CommandLine::StringType::const_iterator> t(path_list,
+                                                     FILE_PATH_LITERAL(","));
+      scoped_refptr<extensions::UnpackedInstaller> installer =
+          extensions::UnpackedInstaller::Create(extension_service_.get());
+      while (t.GetNext()) {
+        installer->LoadFromCommandLine(FilePath(t.token()));
+      }
+    }
+  }
+
+  // Make the chrome://extension-icon/ resource available.
+  GetChromeURLDataManager()->AddDataSource(new ExtensionIconSource(this));
+
+  // Initialize extension event routers. Note that on Chrome OS, this will
+  // not succeed if the user has not logged in yet, in which case the
+  // event routers are initialized in LoginUtilsImpl::CompleteLogin instead.
+  // The InitEventRouters call used to be in BrowserMain, because when bookmark
+  // import happened on first run, the bookmark bar was not being correctly
+  // initialized (see issue 40144). Now that bookmarks aren't imported and
+  // the event routers need to be initialized for every profile individually,
+  // initialize them with the extension service.
+  // If this profile is being created as part of the import process, never
+  // initialize the event routers. If import is going to run in a separate
+  // process (the profile itself is on the main process), wait for import to
+  // finish before initializing the routers.
+  if (!command_line->HasSwitch(switches::kImport) &&
+      !command_line->HasSwitch(switches::kImportFromFile)) {
+    if (g_browser_process->profile_manager()->will_import()) {
+      extension_service_->InitEventRoutersAfterImport();
+    } else {
+      extension_service_->InitEventRouters();
+    }
+  }
+}
+
 void ProfileImpl::InitPromoResources() {
   if (promo_resource_service_)
     return;
 
   promo_resource_service_ = new PromoResourceService(this);
   promo_resource_service_->StartAfterDelay();
 }
 
 void ProfileImpl::InitRegisteredProtocolHandlers() {
   if (protocol_handler_registry_)
@@ skipping 80 matching lines @@
   // HistoryService will join with HistoryService's backend thread so that
   // by the time the destructor has finished we're sure it will no longer call
   // into the BookmarkModel.
   history_service_ = NULL;
   bookmark_bar_model_.reset();
 
   // FaviconService depends on HistoryServce so make sure we delete
   // HistoryService first.
   favicon_service_.reset();
 
+  if (extension_message_service_)
+    extension_message_service_->DestroyingProfile();
+
   if (pref_proxy_config_tracker_.get())
     pref_proxy_config_tracker_->DetachFromPrefService();
 
   if (protocol_handler_registry_)
     protocol_handler_registry_->Finalize();
 
   if (host_content_settings_map_)
     host_content_settings_map_->ShutdownOnUIThread();
 
   // This causes the Preferences file to be written to disk.
@@ skipping 44 matching lines @@
       new VisitedLinkMaster(visited_link_event_listener_.get(), this));
     if (!visited_links->Init())
       return NULL;
     visited_link_master_.swap(visited_links);
   }
 
   return visited_link_master_.get();
 }
 
 ExtensionService* ProfileImpl::GetExtensionService() {
-  return ExtensionSystemFactory::GetForProfile(this)->extension_service();
+  return extension_service_.get();
 }
 
 UserScriptMaster* ProfileImpl::GetUserScriptMaster() {
-  return ExtensionSystemFactory::GetForProfile(this)->user_script_master();
+  return user_script_master_.get();
+}
+
+ExtensionDevToolsManager* ProfileImpl::GetExtensionDevToolsManager() {
+  return extension_devtools_manager_.get();
 }
 
 ExtensionProcessManager* ProfileImpl::GetExtensionProcessManager() {
-  return ExtensionSystemFactory::GetForProfile(this)->process_manager();
+  return extension_process_manager_.get();
+}
+
+ExtensionMessageService* ProfileImpl::GetExtensionMessageService() {
+  return extension_message_service_.get();
 }
 
 ExtensionEventRouter* ProfileImpl::GetExtensionEventRouter() {
-  return ExtensionSystemFactory::GetForProfile(this)->event_router();
+  return extension_event_router_.get();
 }
 
 ExtensionSpecialStoragePolicy*
     ProfileImpl::GetExtensionSpecialStoragePolicy() {
   if (!extension_special_storage_policy_.get()) {
     extension_special_storage_policy_ = new ExtensionSpecialStoragePolicy(
         CookieSettings::Factory::GetForProfile(this));
   }
   return extension_special_storage_policy_.get();
 }
@@ skipping 15 matching lines @@
                                  g_browser_process->local_state());
   }
 
   // The last session exited cleanly if there is no pref for
   // kSessionExitedCleanly or the value for kSessionExitedCleanly is true.
   last_session_exited_cleanly_ =
       prefs_->GetBoolean(prefs::kSessionExitedCleanly);
   // Mark the session as open.
   prefs_->SetBoolean(prefs::kSessionExitedCleanly, false);
 
+  bool extensions_disabled =
+      prefs_->GetBoolean(prefs::kDisableExtensions) ||
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableExtensions);
+
   ProfileDependencyManager::GetInstance()->CreateProfileServices(this, false);
 
+  // Ensure that preferences set by extensions are restored in the profile
+  // as early as possible. The constructor takes care of that.
+  extension_prefs_.reset(new ExtensionPrefs(
+      prefs_.get(),
+      GetPath().AppendASCII(ExtensionService::kInstallDirectoryName),
+      GetExtensionPrefValueMap()));
+  extension_prefs_->Init(extensions_disabled);
+
   DCHECK(!net_pref_observer_.get());
   net_pref_observer_.reset(new NetPrefObserver(
       prefs_.get(),
       prerender::PrerenderManagerFactory::GetForProfile(this),
       predictor_));
 
   DoFinalInit();
 }
 
 PrefService* ProfileImpl::GetPrefs() {
@@ skipping 24 matching lines @@
   // Even when Chromium is started in OTR mode, a normal profile is always
   // created first.
   if (!default_request_context_)
     default_request_context_ = request_context;
 
   return request_context;
 }
 
 net::URLRequestContextGetter* ProfileImpl::GetRequestContextForRenderProcess(
     int renderer_child_id) {
-  ExtensionService* extension_service =
-      ExtensionSystemFactory::GetForProfile(this)->extension_service();
-  if (extension_service) {
-    const Extension* installed_app = extension_service->
+  if (extension_service_.get()) {
+    const Extension* installed_app = extension_service_->
         GetInstalledAppForRenderer(renderer_child_id);
     if (installed_app != NULL && installed_app->is_storage_isolated() &&
         installed_app->HasAPIPermission(
             ExtensionAPIPermission::kExperimental)) {
       return GetRequestContextForIsolatedApp(installed_app->id());
     }
   }
   return GetRequestContext();
 }
 
@@ skipping 15 matching lines @@
 
 net::URLRequestContextGetter* ProfileImpl::GetRequestContextForExtensions() {
   return io_data_.GetExtensionsRequestContextGetter();
 }
 
 net::URLRequestContextGetter* ProfileImpl::GetRequestContextForIsolatedApp(
     const std::string& app_id) {
   return io_data_.GetIsolatedAppRequestContextGetter(app_id);
 }
 
+void ProfileImpl::RegisterExtensionWithRequestContexts(
+    const Extension* extension) {
+  base::Time install_time;
+  if (extension->location() != Extension::COMPONENT) {
+    install_time = GetExtensionService()->extension_prefs()->
+        GetInstallTime(extension->id());
+  }
+  bool incognito_enabled =
+      GetExtensionService()->IsIncognitoEnabled(extension->id());
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&ExtensionInfoMap::AddExtension, extension_info_map_.get(),
+                 make_scoped_refptr(extension), install_time,
+                 incognito_enabled));
+}
+
+void ProfileImpl::UnregisterExtensionWithRequestContexts(
+    const std::string& extension_id,
+    const extension_misc::UnloadedExtensionReason reason) {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&ExtensionInfoMap::RemoveExtension, extension_info_map_.get(),
+                 extension_id, reason));
+}
+
 net::SSLConfigService* ProfileImpl::GetSSLConfigService() {
   return ssl_config_service_manager_->Get();
 }
 
 HostContentSettingsMap* ProfileImpl::GetHostContentSettingsMap() {
   if (!host_content_settings_map_.get()) {
     host_content_settings_map_ = new HostContentSettingsMap(
         GetPrefs(), GetExtensionService(), false);
   }
   return host_content_settings_map_.get();
@@ skipping 359 matching lines @@
   SessionServiceFactory::GetForProfile(this);
 }
 
 TokenService* ProfileImpl::GetTokenService() {
   if (!token_service_.get()) {
     token_service_.reset(new TokenService());
   }
   return token_service_.get();
 }
 
+ExtensionInfoMap* ProfileImpl::GetExtensionInfoMap() {
+  return extension_info_map_.get();
+}
+
 ChromeURLDataManager* ProfileImpl::GetChromeURLDataManager() {
   if (!chrome_url_data_manager_.get())
     chrome_url_data_manager_.reset(new ChromeURLDataManager(
         io_data_.GetChromeURLDataManagerBackendGetter()));
   return chrome_url_data_manager_.get();
 }
 
 PromoCounter* ProfileImpl::GetInstantPromoCounter() {
 #if defined(OS_WIN)
   // TODO: enable this when we're ready to turn on the promo.
@@ skipping 195 matching lines @@
                                      FilePath* cache_path,
                                      int* max_size) {
   DCHECK(cache_path);
   DCHECK(max_size);
   FilePath path(prefs_->GetFilePath(prefs::kDiskCacheDir));
   if (!path.empty())
     *cache_path = path;
   *max_size = is_media_context ? prefs_->GetInteger(prefs::kMediaCacheSize) :
                                  prefs_->GetInteger(prefs::kDiskCacheSize);
 }