Removal of Profile from content part 1.

chrome/browser/extensions/extension_process_manager.cc

 // Copyright (c) 2011 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/extension_process_manager.h"
 
 #include "chrome/browser/ui/browser_window.h"
 #include "content/browser/browsing_instance.h"
 #if defined(OS_MACOSX)
 #include "chrome/browser/extensions/extension_host_mac.h"
@@ skipping 114 matching lines @@
 #endif
   host->CreateView(browser);
   OnExtensionHostCreated(host, false);
   return host;
 }
 
 ExtensionHost* ExtensionProcessManager::CreateViewHost(
     const GURL& url, Browser* browser, ViewType::Type view_type) {
   // A NULL browser may only be given for pop-up views.
   DCHECK(browser || (!browser && view_type == ViewType::EXTENSION_POPUP));
-  ExtensionService* service =
-      browsing_instance_->profile()->GetExtensionService();
+  Profile* profile = static_cast<Profile*>(browsing_instance_->context());
+  ExtensionService* service = profile->GetExtensionService();
   if (service) {
     const Extension* extension = service->GetExtensionByURL(url);
     if (extension)
       return CreateViewHost(extension, url, browser, view_type);
   }
   return NULL;
 }
 
 ExtensionHost* ExtensionProcessManager::CreatePopupHost(
     const Extension* extension, const GURL& url, Browser* browser) {
@@ skipping 44 matching lines @@
   OnExtensionHostCreated(host, true);
 }
 
 void ExtensionProcessManager::OpenOptionsPage(const Extension* extension,
                                               Browser* browser) {
   DCHECK(!extension->options_url().is_empty());
 
   // Force the options page to open in non-OTR window, because it won't be
   // able to save settings from OTR.
   if (!browser || browser->profile()->IsOffTheRecord()) {
-    browser = Browser::GetOrCreateTabbedBrowser(
-        browsing_instance_->profile()->GetOriginalProfile());
+    Profile* profile = static_cast<Profile*>(browsing_instance_->context());
+    browser = Browser::GetOrCreateTabbedBrowser(profile->GetOriginalProfile());
   }
 
   browser->OpenURL(extension->options_url(), GURL(), SINGLETON_TAB,
                    PageTransition::LINK);
   browser->window()->Show();
   static_cast<RenderViewHostDelegate*>(browser->GetSelectedTabContents())->
       Activate();
 }
 
 ExtensionHost* ExtensionProcessManager::GetBackgroundHostForExtension(
@@ skipping 42 matching lines @@
   return GetExtensionProcess(
       Extension::GetBaseURLFromExtensionId(extension_id));
 }
 
 const Extension* ExtensionProcessManager::GetExtensionForSiteInstance(
     int site_instance_id) {
   SiteInstanceIDMap::const_iterator it = extension_ids_.find(site_instance_id);
   if (it != extension_ids_.end()) {
     // Look up the extension by ID, including disabled extensions in case
     // this gets called while an old process is still around.
-    ExtensionService* service =
-        browsing_instance_->profile()->GetExtensionService();
+    Profile* profile = static_cast<Profile*>(browsing_instance_->context());
+    ExtensionService* service = profile->GetExtensionService();
     return service->GetExtensionById(it->second, false);
   }
 
   return NULL;
 }
 
 SiteInstance* ExtensionProcessManager::GetSiteInstanceForURL(const GURL& url) {
   return browsing_instance_->GetSiteInstanceForURL(url);
 }
 
@@ skipping 58 matching lines @@
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 void ExtensionProcessManager::OnExtensionHostCreated(ExtensionHost* host,
                                                      bool is_background) {
-  DCHECK_EQ(browsing_instance_->profile(), host->profile());
+  Profile* profile = static_cast<Profile*>(browsing_instance_->context());
+  DCHECK_EQ(profile, host->profile());
 
   all_hosts_.insert(host);
   if (is_background)
     background_hosts_.insert(host);
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_HOST_CREATED,
       Source<ExtensionProcessManager>(this),
       Details<ExtensionHost>(host));
 }
 
@@ skipping 79 matching lines @@
       ExtensionProcessManager::GetExtensionForSiteInstance(site_instance_id);
   if (extension && extension->incognito_split_mode()) {
     return extension;
   } else {
     return original_manager_->GetExtensionForSiteInstance(site_instance_id);
   }
 }
 
 const Extension* IncognitoExtensionProcessManager::GetExtensionOrAppByURL(
     const GURL& url) {
-  ExtensionService* service =
-      browsing_instance_->profile()->GetExtensionService();
+  Profile* profile = static_cast<Profile*>(browsing_instance_->context());
+  ExtensionService* service = profile->GetExtensionService();
   if (!service)
     return NULL;
   return (url.SchemeIs(chrome::kExtensionScheme)) ?
       service->GetExtensionByURL(url) : service->GetExtensionByWebExtent(url);
 }
 
 bool IncognitoExtensionProcessManager::IsIncognitoEnabled(
     const Extension* extension) {
-  ExtensionService* service =
-      browsing_instance_->profile()->GetExtensionService();
+  Profile* profile = static_cast<Profile*>(browsing_instance_->context());
+  ExtensionService* service = profile->GetExtensionService();
   return service && service->IsIncognitoEnabled(extension->id());
 }
 
 void IncognitoExtensionProcessManager::Observe(
     int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_BROWSER_WINDOW_READY: {
       // We want to spawn our background hosts as soon as the user opens an
       // incognito window. Watch for new browsers and create the hosts if
       // it matches our profile.
       Browser* browser = Source<Browser>(source).ptr();
-      if (browser->profile() == browsing_instance_->profile()) {
+      Profile* profile = static_cast<Profile*>(browsing_instance_->context());
+      if (browser->profile() == profile) {
         // On Chrome OS, a login screen is implemented as a browser.
         // This browser has no extension service.  In this case,
         // service will be NULL.
-        ExtensionService* service =
-            browsing_instance_->profile()->GetExtensionService();
+        ExtensionService* service = profile->GetExtensionService();
         if (service && service->is_ready())
           CreateBackgroundHosts(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }