Allow app_shell to run past extension manifest parsing

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/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 26 matching lines @@
 const char kUpdateThrottled[] = "throttled";
 
 // A preference key storing the url loaded when an extension is uninstalled.
 const char kUninstallUrl[] = "uninstall_url";
 
 // The name of the directory to be returned by getPackageDirectoryEntry. This
 // particular value does not matter to user code, but is chosen for consistency
 // with the equivalent Pepper API.
 const char kPackageDirectoryPath[] = "crxfs";
 
-static void DispatchOnStartupEventImpl(
-    Profile* profile,
-    const std::string& extension_id,
-    bool first_call,
-    ExtensionHost* host) {
+void DispatchOnStartupEventImpl(BrowserContext* browser_context,
+                                const std::string& extension_id,
+                                bool first_call,
+                                ExtensionHost* host) {
   // A NULL host from the LazyBackgroundTaskQueue means the page failed to
   // load. Give up.
   if (!host && !first_call)
     return;
 
-  // Don't send onStartup events to incognito profiles.
-  if (profile->IsOffTheRecord())
+  // Don't send onStartup events to incognito browser contexts.
+  if (browser_context->IsOffTheRecord())
     return;
 
-  if (g_browser_process->IsShuttingDown() ||
-      !g_browser_process->profile_manager()->IsValidProfile(profile))
+  if (ExtensionsBrowserClient::Get()->IsShuttingDown() ||
+      !ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
     return;
-  ExtensionSystem* system = ExtensionSystem::Get(profile);
+  ExtensionSystem* system =
+      ExtensionSystem::GetForBrowserContext(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 =
-      system->extension_service()->extensions()->GetByID(extension_id);
+      ExtensionRegistry::Get(browser_context)->enabled_extensions().GetByID(
+          extension_id);
   if (extension && BackgroundInfo::HasPersistentBackgroundPage(extension) &&
       first_call &&
       system->lazy_background_task_queue()->
-          ShouldEnqueueTask(profile, extension)) {
+          ShouldEnqueueTask(browser_context, extension)) {
     system->lazy_background_task_queue()->AddPendingTask(
-        profile, extension_id,
+        browser_context, extension_id,
         base::Bind(&DispatchOnStartupEventImpl,
-                   profile, extension_id, false));
+                   browser_context, extension_id, false));
     return;
   }
 
   scoped_ptr<base::ListValue> event_args(new base::ListValue());
   scoped_ptr<Event> event(new Event(runtime::OnStartup::kEventName,
                                     event_args.Pass()));
   system->event_router()->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void SetUninstallUrl(ExtensionPrefs* prefs,
@@ skipping 133 matching lines @@
 void RuntimeAPI::OnChromeUpdateAvailable() {
   Profile* profile = Profile::FromBrowserContext(browser_context_);
   RuntimeEventRouter::DispatchOnBrowserUpdateAvailableEvent(profile);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // static
 void RuntimeEventRouter::DispatchOnStartupEvent(
     content::BrowserContext* context, const std::string& extension_id) {
-  // TODO(jamescook): Convert to BrowserContext all the way down.
-  Profile* profile = static_cast<Profile*>(context);
-  DispatchOnStartupEventImpl(profile, extension_id, true, NULL);
+  DispatchOnStartupEventImpl(context, extension_id, true, NULL);
 }
 
 // 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;
@@ skipping 297 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