Split ExtensionSystem interface from ExtensionSystemImpl implementation, part 1.

chrome/browser/extensions/api/runtime/runtime_api.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/extensions/api/runtime/runtime_api.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/extensions/api/runtime.h"
 #include "chrome/common/omaha_query_params/omaha_query_params.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "url/gurl.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 
 #if defined(OS_CHROMEOS)
@@ skipping 42 matching lines @@
   if (!host && !first_call)
     return;
 
   // Don't send onStartup events to incognito browser contexts.
   if (browser_context->IsOffTheRecord())
     return;
 
   if (ExtensionsBrowserClient::Get()->IsShuttingDown() ||
       !ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
     return;
-  ExtensionSystem* system =
-      ExtensionSystem::GetForBrowserContext(browser_context);
+  ExtensionSystem* system = ExtensionSystem::Get(browser_context);
   if (!system)
     return;
 
   // If this is a persistent background page, we want to wait for it to load
   // (it might not be ready, since this is startup). But only enqueue once.
   // If it fails to load the first time, don't bother trying again.
   const Extension* extension =
       ExtensionRegistry::Get(browser_context)->enabled_extensions().GetByID(
           extension_id);
   if (extension && BackgroundInfo::HasPersistentBackgroundPage(extension) &&
@@ skipping 48 matching lines @@
                  content::Source<BrowserContext>(context));
 
   // Check if registered events are up-to-date. We can only do this once
   // per browser context, since it updates internal state when called.
   dispatch_chrome_updated_event_ =
       ExtensionsBrowserClient::Get()->DidVersionUpdate(browser_context_);
 }
 
 RuntimeAPI::~RuntimeAPI() {
   if (registered_for_updates_) {
-    ExtensionSystem::GetForBrowserContext(browser_context_)->
+    ExtensionSystem::Get(browser_context_)->
         extension_service()->RemoveUpdateObserver(this);
   }
 }
 
 void RuntimeAPI::Observe(int type,
                          const content::NotificationSource& source,
                          const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSIONS_READY: {
       OnExtensionsReady();
@@ skipping 22 matching lines @@
       break;
   }
 }
 
 void RuntimeAPI::OnExtensionsReady() {
   // We're done restarting Chrome after an update.
   dispatch_chrome_updated_event_ = false;
 
   registered_for_updates_ = true;
 
-  ExtensionSystem::GetForBrowserContext(browser_context_)->extension_service()->
+  ExtensionSystem::Get(browser_context_)->extension_service()->
       AddUpdateObserver(this);
 }
 
 void RuntimeAPI::OnExtensionLoaded(const Extension* extension) {
   if (!dispatch_chrome_updated_event_)
     return;
 
   // Dispatch the onInstalled event with reason "chrome_update".
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&RuntimeEventRouter::DispatchOnInstalledEvent,
                  browser_context_,
                  extension->id(),
                  Version(),
                  true));
 }
 
 void RuntimeAPI::OnExtensionInstalled(const Extension* extension) {
   // Ephemeral apps are not considered to be installed and do not receive
   // the onInstalled() event.
   if (extension->is_ephemeral())
     return;
 
   // Get the previous version to check if this is an upgrade.
-  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
+  ExtensionService* service = ExtensionSystem::Get(
       browser_context_)->extension_service();
   const Extension* old = service->GetExtensionById(extension->id(), true);
   Version old_version;
   if (old)
     old_version = *old->version();
 
   // Dispatch the onInstalled event.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&RuntimeEventRouter::DispatchOnInstalledEvent,
@@ skipping 34 matching lines @@
 }
 
 // static
 void RuntimeEventRouter::DispatchOnInstalledEvent(
     content::BrowserContext* context,
     const std::string& extension_id,
     const Version& old_version,
     bool chrome_updated) {
   if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
     return;
-  ExtensionSystem* system = ExtensionSystem::GetForBrowserContext(context);
+  ExtensionSystem* system = ExtensionSystem::Get(context);
   if (!system)
     return;
 
   scoped_ptr<base::ListValue> event_args(new base::ListValue());
   base::DictionaryValue* info = new base::DictionaryValue();
   event_args->Append(info);
   if (old_version.IsValid()) {
     info->SetString(kInstallReason, kInstallReasonUpdate);
     info->SetString(kInstallPreviousVersion, old_version.GetString());
   } else if (chrome_updated) {
@@ skipping 286 matching lines @@
       content::ChildProcessSecurityPolicy::GetInstance();
   policy->GrantReadFileSystem(renderer_id, filesystem_id);
   base::DictionaryValue* dict = new base::DictionaryValue();
   SetResult(dict);
   dict->SetString("fileSystemId", filesystem_id);
   dict->SetString("baseName", relative_path);
   return true;
 }
 
 }   // namespace extensions