Removal of Profile from content part 1.

chrome/browser/extensions/extension_host.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_host.h"
 
 #include <list>
 
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
@@ skipping 114 matching lines @@
 
 ////////////////
 // ExtensionHost
 
 ExtensionHost::ExtensionHost(const Extension* extension,
                              SiteInstance* site_instance,
                              const GURL& url,
                              ViewType::Type host_type)
     : extension_(extension),
       extension_id_(extension->id()),
-      profile_(site_instance->browsing_instance()->profile()),
+      profile_(static_cast<Profile*>(
+          site_instance->browsing_instance()->context())),
       did_stop_loading_(false),
       document_element_available_(false),
       url_(url),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           extension_function_dispatcher_(profile_, this)),
       extension_host_type_(host_type),
       associated_tab_contents_(NULL) {
   render_view_host_ = new RenderViewHost(site_instance, this, MSG_ROUTING_NONE,
                                          NULL);
   if (enable_dom_automation_)
@@ skipping 336 matching lines @@
   if (extension_host_type_ == ViewType::EXTENSION_POPUP ||
       extension_host_type_ == ViewType::EXTENSION_DIALOG ||
       extension_host_type_ == ViewType::EXTENSION_INFOBAR) {
     NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
         Source<Profile>(profile_),
         Details<ExtensionHost>(this));
   }
 }
 
-RendererPreferences ExtensionHost::GetRendererPrefs(Profile* profile) const {
+RendererPreferences ExtensionHost::GetRendererPrefs(
+    content::BrowserContext* context) const {
+  Profile* profile = static_cast<Profile*>(context);
   RendererPreferences preferences;
 
   TabContents* associated_contents = GetAssociatedTabContents();
   if (associated_contents)
     preferences =
         static_cast<RenderViewHostDelegate*>(associated_contents)->
             GetRendererPrefs(profile);
 
   renderer_preferences_util::UpdateFromSystemSettings(&preferences, profile);
   return preferences;
 }
 
 WebPreferences ExtensionHost::GetWebkitPrefs() {
-  Profile* profile = render_view_host()->process()->profile();
+  Profile* profile =
+      static_cast<Profile*>(render_view_host()->process()->context());
   WebPreferences webkit_prefs =
       RenderViewHostDelegateHelper::GetWebkitPrefs(profile,
                                                    false);  // is_web_ui
   // Extensions are trusted so we override any user preferences for disabling
   // javascript or images.
   webkit_prefs.loads_images_automatically = true;
   webkit_prefs.javascript_enabled = true;
 
   if (extension_host_type_ == ViewType::EXTENSION_POPUP ||
       extension_host_type_ == ViewType::EXTENSION_DIALOG ||
@@ skipping 61 matching lines @@
 }
 
 void ExtensionHost::HandleMouseActivate() {
 }
 
 void ExtensionHost::CreateNewWindow(
     int route_id,
     const ViewHostMsg_CreateWindow_Params& params) {
   // TODO(aa): Use the browser's profile if the extension is split mode
   // incognito.
+  Profile* profile =
+      static_cast<Profile*>(render_view_host()->process()->context());
   TabContents* new_contents = delegate_view_helper_.CreateNewWindow(
       route_id,
-      render_view_host()->process()->profile(),
+      profile,
       site_instance(),
       ChromeWebUIFactory::GetInstance()->GetWebUIType(
-          render_view_host()->process()->profile(), url_),
+          render_view_host()->process()->context(), url_),
       this,
       params.window_container_type,
       params.frame_name);
 
   TabContents* associated_contents = GetAssociatedTabContents();
   if (associated_contents && associated_contents->delegate())
     associated_contents->delegate()->TabContentsCreated(new_contents);
 }
 
 void ExtensionHost::CreateNewWidget(int route_id,
@@ skipping 12 matching lines @@
                                                site_instance()->GetProcess());
 }
 
 void ExtensionHost::ShowCreatedWindow(int route_id,
                                       WindowOpenDisposition disposition,
                                       const gfx::Rect& initial_pos,
                                       bool user_gesture) {
   TabContents* contents = delegate_view_helper_.GetCreatedWindow(route_id);
   if (!contents)
     return;
+  Profile* profile = static_cast<Profile*>(contents->context());
 
   if (disposition == NEW_POPUP) {
     // Find a browser with a matching profile for creating a popup.
     // (If none is found, NULL argument to NavigateParams is valid.)
     Browser* browser = BrowserList::FindTabbedBrowser(
-        contents->profile(),
-        false);  // Match incognito exactly.
+        profile, false);  // Match incognito exactly.
     TabContentsWrapper* wrapper = new TabContentsWrapper(contents);
     browser::NavigateParams params(browser, wrapper);
     if (!browser)
-      params.profile = contents->profile();
+      params.profile = profile;
     // The extension_app_id parameter ends up as app_name in the Browser
     // which causes the Browser to return true for is_app().  This affects
     // among other things, whether the location bar gets displayed.
     params.extension_app_id = extension_id_;
     params.disposition = NEW_POPUP;
     params.window_bounds = initial_pos;
     params.window_action = browser::NavigateParams::SHOW_WINDOW;
     params.user_gesture = user_gesture;
     browser::Navigate(&params);
     return;
   }
 
   // If the tab contents isn't a popup, it's a normal tab. We need to find a
   // home for it. This is typically a Browser, but it can also be some other
   // TabContentsDelegate in the case of ChromeFrame.
 
   // First, if the creating extension view was associated with a tab contents,
   // use that tab content's delegate. We must be careful here that the
   // associated tab contents has the same profile as the new tab contents. In
   // the case of extensions in 'spanning' incognito mode, they can mismatch.
   // We don't want to end up putting a normal tab into an incognito window, or
   // vice versa.
   TabContents* associated_contents = GetAssociatedTabContents();
   if (associated_contents &&
-      associated_contents->profile() == contents->profile()) {
+      associated_contents->context() == contents->context()) {
     associated_contents->AddNewContents(
         contents, disposition, initial_pos, user_gesture);
     return;
   }
 
   // If there's no associated tab contents, or it doesn't have a matching
   // profile, try finding an open window. Again, we must make sure to find a
   // window with the correct profile.
   Browser* browser = BrowserList::FindTabbedBrowser(
-        contents->profile(),
-        false);  // Match incognito exactly.
+        profile, false);  // Match incognito exactly.
 
   // If there's no Browser open with the right profile, create a new one.
   if (!browser) {
-    browser = Browser::Create(contents->profile());
+    browser = Browser::Create(profile);
     browser->window()->Show();
   }
   browser->AddTabContents(contents, disposition, initial_pos, user_gesture);
 }
 
 void ExtensionHost::ShowCreatedWidget(int route_id,
                                       const gfx::Rect& initial_pos) {
   ShowCreatedWidgetInternal(delegate_view_helper_.GetCreatedWidget(route_id),
                             initial_pos);
 }
@@ skipping 99 matching lines @@
   }
 }
 
 void ExtensionHost::OnRunFileChooser(
     const ViewHostMsg_RunFileChooser_Params& params) {
   if (file_select_helper_.get() == NULL)
     file_select_helper_.reset(new FileSelectHelper(profile()));
   file_select_helper_->RunFileChooser(render_view_host_,
                                       GetAssociatedTabContents(), params);
 }