app_shell: Extract extension runtime data from ExtensionService

chrome/browser/automation/testing_automation_provider.cc

 // Copyright 2013 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/automation/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 3434 matching lines @@
         "Missing or invalid 'path'");
     return;
   }
   if (!args->GetBoolean("with_ui", &with_ui)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Missing or invalid 'with_ui'");
     return;
   }
   args->GetBoolean("from_webstore", &from_webstore);
 
-  ExtensionService* service = extensions::ExtensionSystem::Get(
-      browser->profile())->extension_service();
-  extensions::ProcessManager* manager =
-      extensions::ExtensionSystem::Get(browser->profile())->process_manager();
-  if (service && manager) {
+  extensions::ExtensionSystem* system =
+      extensions::ExtensionSystem::Get(browser->profile());
+  ExtensionService* service = system->extension_service();
+  if (service) {
     // The observer will delete itself when done.
     new ExtensionReadyNotificationObserver(
-        manager,
-        service,
+        system,
         this,
         reply_message);
 
     base::FilePath extension_path(path_string);
     // If the given path has a 'crx' extension, assume it is a packed extension
     // and install it. Otherwise load it as an unpacked extension.
     if (extension_path.MatchesExtension(FILE_PATH_LITERAL(".crx"))) {
       scoped_ptr<ExtensionInstallPrompt> client(
           with_ui ? new ExtensionInstallPrompt(tab) : NULL);
       scoped_refptr<extensions::CrxInstaller> installer(
           extensions::CrxInstaller::Create(service, client.Pass()));
       if (!with_ui)
         installer->set_allow_silent_install(true);
       installer->set_install_cause(extension_misc::INSTALL_CAUSE_AUTOMATION);
       if (from_webstore)
         installer->set_creation_flags(Extension::FROM_WEBSTORE);
       installer->InstallCrx(extension_path);
     } else {
       scoped_refptr<extensions::UnpackedInstaller> installer(
           extensions::UnpackedInstaller::Create(service));
       installer->set_prompt_for_plugins(with_ui);
       installer->Load(extension_path);
     }
   } else {
     AutomationJSONReply(this, reply_message).SendError(
-        "Extensions service/process manager is not available");
+        "Extensions service is not available");
   }
 }
 
 namespace {
 
 base::ListValue* GetHostPermissions(const Extension* ext, bool effective_perm) {
   extensions::URLPatternSet pattern_set;
   if (effective_perm) {
     pattern_set =
         extensions::PermissionsData::GetEffectiveHostPermissions(ext);
@@ skipping 159 matching lines @@
     return;
   }
 
   if (allow_in_incognito && !enable) {
     AutomationJSONReply(this, reply_message)
         .SendError("Invalid state: Disabled extension "
                     "cannot be allowed in incognito mode.");
     return;
   }
 
-  ExtensionService* service = extensions::ExtensionSystem::Get(
-      browser->profile())->extension_service();
-  extensions::ProcessManager* manager =
-      extensions::ExtensionSystem::Get(browser->profile())->process_manager();
+  extensions::ExtensionSystem* system =
+      extensions::ExtensionSystem::Get(browser->profile());
+  ExtensionService* service = system->extension_service();
   if (!service) {
     AutomationJSONReply(this, reply_message)
-        .SendError("No extensions service or process manager.");
+        .SendError("No extensions service.");
     return;
   }
 
   if (enable) {
     if (!service->IsExtensionEnabled(extension->id())) {
       new ExtensionReadyNotificationObserver(
-          manager,
-          service,
+          system,
           this,
           reply_message);
       service->EnableExtension(extension->id());
     } else {
       AutomationJSONReply(this, reply_message).SendSuccess(NULL);
     }
   } else {
     service->DisableExtension(extension->id(),
                               Extension::DISABLE_USER_ACTION);
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
@@ skipping 1770 matching lines @@
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 void TestingAutomationProvider::EnsureTabSelected(Browser* browser,
                                                   WebContents* tab) {
   TabStripModel* tab_strip = browser->tab_strip_model();
   if (tab_strip->GetActiveWebContents() != tab)
     tab_strip->ActivateTabAt(tab_strip->GetIndexOfWebContents(tab), true);
 }