Removal of Profile from content part 1.

content/browser/tab_contents/tab_contents.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 "content/browser/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/download/download_util.h"
-#include "chrome/browser/profiles/profile.h"
+#include "content/browser/browser_context.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/content_browser_client.h"
 #include "content/browser/debugger/devtools_manager.h"
 #include "content/browser/host_zoom_map.h"
 #include "content/browser/in_process_webkit/session_storage_namespace.h"
 #include "content/browser/load_from_memory_cache_details.h"
 #include "content/browser/load_notification_details.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
@@ skipping 85 matching lines @@
 
 BOOL CALLBACK InvalidateWindow(HWND hwnd, LPARAM lparam) {
   // Note: erase is required to properly paint some widgets borders. This can
   // be seen with textfields.
   InvalidateRect(hwnd, NULL, TRUE);
   return TRUE;
 }
 #endif
 
 ViewMsg_Navigate_Type::Value GetNavigationType(
-    Profile* profile, const NavigationEntry& entry,
+    content::BrowserContext* context, const NavigationEntry& entry,
     NavigationController::ReloadType reload_type) {
   switch (reload_type) {
     case NavigationController::RELOAD:
       return ViewMsg_Navigate_Type::RELOAD;
     case NavigationController::RELOAD_IGNORING_CACHE:
       return ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE;
     case NavigationController::NO_RELOAD:
       break;  // Fall through to rest of function.
   }
 
   if (entry.restore_type() == NavigationEntry::RESTORE_LAST_SESSION &&
-      profile->DidLastSessionExitCleanly())
+      context->DidLastSessionExitCleanly())
     return ViewMsg_Navigate_Type::RESTORE;
 
   return ViewMsg_Navigate_Type::NORMAL;
 }
 
 void MakeNavigateParams(const NavigationEntry& entry,
                         const NavigationController& controller,
                         NavigationController::ReloadType reload_type,
                         ViewMsg_Navigate_Params* params) {
   params->page_id = entry.page_id();
   params->pending_history_list_offset = controller.GetIndexOfEntry(&entry);
   params->current_history_list_offset = controller.last_committed_entry_index();
   params->current_history_list_length = controller.entry_count();
   params->url = entry.url();
   params->referrer = entry.referrer();
   params->transition = entry.transition_type();
   params->state = entry.content_state();
   params->navigation_type =
-      GetNavigationType(controller.profile(), entry, reload_type);
+      GetNavigationType(controller.context(), entry, reload_type);
   params->request_time = base::Time::Now();
 }
 
 }  // namespace
 
 
 // TabContents ----------------------------------------------------------------
 
-TabContents::TabContents(Profile* profile,
+TabContents::TabContents(content::BrowserContext* context,
                          SiteInstance* site_instance,
                          int routing_id,
                          const TabContents* base_tab_contents,
                          SessionStorageNamespace* session_storage_namespace)
     : delegate_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(controller_(
-          this, profile, session_storage_namespace)),
+          this, context, session_storage_namespace)),
       ALLOW_THIS_IN_INITIALIZER_LIST(view_(
           TabContentsView::Create(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(render_manager_(this, this)),
       is_loading_(false),
       crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
       crashed_error_code_(0),
       waiting_for_response_(false),
       max_page_id_(-1),
       load_state_(net::LOAD_STATE_IDLE),
       upload_size_(0),
       upload_position_(0),
       displayed_insecure_content_(false),
       capturing_contents_(false),
       is_being_destroyed_(false),
       notify_disconnection_(false),
 #if defined(OS_WIN)
       message_box_active_(CreateEvent(NULL, TRUE, FALSE, NULL)),
 #endif
       is_showing_before_unload_dialog_(false),
       opener_web_ui_type_(WebUI::kNoWebUI),
       closed_by_user_gesture_(false),
       minimum_zoom_percent_(
           static_cast<int>(WebKit::WebView::minTextSizeMultiplier * 100)),
       maximum_zoom_percent_(
           static_cast<int>(WebKit::WebView::maxTextSizeMultiplier * 100)),
       temporary_zoom_settings_(false),
       content_restrictions_(0) {
 
-  render_manager_.Init(profile, site_instance, routing_id);
+  render_manager_.Init(context, site_instance, routing_id);
 
   // We have the initial size of the view be based on the size of the passed in
   // tab contents (normally a tab from the same window).
   view_->CreateView(base_tab_contents ?
       base_tab_contents->view()->GetContainerSize() : gfx::Size());
 }
 
 TabContents::~TabContents() {
   is_being_destroyed_ = true;
 
@@ skipping 311 matching lines @@
     const NavigationEntry& entry,
     NavigationController::ReloadType reload_type) {
   RenderViewHost* dest_render_view_host = render_manager_.Navigate(entry);
   if (!dest_render_view_host)
     return false;  // Unable to create the desired render view host.
 
   // For security, we should never send non-Web-UI URLs to a Web UI renderer.
   // Double check that here.
   int enabled_bindings = dest_render_view_host->enabled_bindings();
   bool is_allowed_in_web_ui_renderer = content::GetContentClient()->
-      browser()->GetWebUIFactory()->IsURLAcceptableForWebUI(profile(),
+      browser()->GetWebUIFactory()->IsURLAcceptableForWebUI(context(),
                                                             entry.url());
   CHECK(!BindingsPolicy::is_web_ui_enabled(enabled_bindings) ||
         is_allowed_in_web_ui_renderer);
 
   // Tell DevTools agent that it is attached prior to the navigation.
   DevToolsManager* devtools_manager = DevToolsManager::GetInstance();
   if (devtools_manager) {  // NULL in unit tests.
     devtools_manager->OnNavigatingToPendingEntry(render_view_host(),
                                                  dest_render_view_host,
                                                  entry.url());
@@ skipping 34 matching lines @@
 
 void TabContents::Stop() {
   render_manager_.Stop();
   FOR_EACH_OBSERVER(TabContentsObserver, observers_, StopNavigation());
 }
 
 TabContents* TabContents::Clone() {
   // We create a new SiteInstance so that the new tab won't share processes
   // with the old one. This can be changed in the future if we need it to share
   // processes for some reason.
-  TabContents* tc = new TabContents(profile(),
-                                    SiteInstance::CreateSiteInstance(profile()),
+  TabContents* tc = new TabContents(context(),
+                                    SiteInstance::CreateSiteInstance(context()),
                                     MSG_ROUTING_NONE, this, NULL);
   tc->controller().CopyStateFrom(controller_);
   return tc;
 }
 
 void TabContents::ShowPageInfo(const GURL& url,
                                const NavigationEntry::SSLStatus& ssl,
                                bool show_history) {
   if (!delegate_)
     return;
 
-  delegate_->ShowPageInfo(profile(), url, ssl, show_history);
+  delegate_->ShowPageInfo(context(), url, ssl, show_history);
 }
 
 ConstrainedWindow* TabContents::CreateConstrainedDialog(
       ConstrainedWindowDelegate* delegate) {
   ConstrainedWindow* window =
       ConstrainedWindow::CreateConstrainedDialog(this, delegate);
   AddConstrainedDialog(window);
   return window;
 }
 
@@ skipping 93 matching lines @@
   } else {
     if (removed_topmost_window)
       child_windows_[0]->ShowConstrainedWindow();
     BlockTabContent(true);
   }
 }
 
 void TabContents::OnSavePage() {
   // If we can not save the page, try to download it.
   if (!SavePackage::IsSavableContents(contents_mime_type())) {
-    DownloadManager* dlm = profile()->GetDownloadManager();
+    DownloadManager* dlm = context()->GetDownloadManager();
     const GURL& current_page_url = GetURL();
     if (dlm && current_page_url.is_valid()) {
       dlm->DownloadUrl(current_page_url, GURL(), "", this);
       download_util::RecordDownloadCount(
           download_util::INITIATED_BY_SAVE_PACKAGE_FAILURE_COUNT);
       return;
     }
   }
 
   Stop();
@@ skipping 11 matching lines @@
 bool TabContents::SavePage(const FilePath& main_file, const FilePath& dir_path,
                            SavePackage::SavePackageType save_type) {
   // Stop the page from navigating.
   Stop();
 
   save_package_ = new SavePackage(this, save_type, main_file, dir_path);
   return save_package_->Init();
 }
 
 void TabContents::OnSaveURL(const GURL& url) {
-  DownloadManager* dlm = profile()->GetDownloadManager();
+  DownloadManager* dlm = context()->GetDownloadManager();
   dlm->DownloadUrl(url, GetURL(), "", this);
 }
 
 bool TabContents::IsActiveEntry(int32 page_id) {
   NavigationEntry* active_entry = controller_.GetActiveEntry();
   return (active_entry != NULL &&
           active_entry->site_instance() == GetSiteInstance() &&
           active_entry->page_id() == page_id);
 }
 
@@ skipping 27 matching lines @@
 }
 
 void TabContents::SystemDragEnded() {
   if (render_view_host())
     render_view_host()->DragSourceSystemDragEnded();
   if (delegate())
     delegate()->DragEnded();
 }
 
 double TabContents::GetZoomLevel() const {
-  HostZoomMap* zoom_map = profile()->GetHostZoomMap();
+  HostZoomMap* zoom_map = context()->GetHostZoomMap();
   if (!zoom_map)
     return 0;
 
   double zoom_level;
   if (temporary_zoom_settings_) {
     zoom_level = zoom_map->GetTemporaryZoomLevel(
         GetRenderProcessHost()->id(), render_view_host()->routing_id());
   } else {
     zoom_level = zoom_map->GetZoomLevel(net::GetHostOrSpecFromURL(GetURL()));
   }
@@ skipping 301 matching lines @@
   //  - Normal state with no load: committed nav entry + no pending nav entry:
   //    -> Use committed Web UI.
   if (controller_.pending_entry() &&
       (controller_.GetLastCommittedEntry() ||
        render_manager_.pending_web_ui()))
     return render_manager_.pending_web_ui();
   return render_manager_.web_ui();
 }
 
 WebUI::TypeID TabContents::GetWebUITypeForCurrentState() {
-  return content::WebUIFactory::Get()->GetWebUIType(profile(), GetURL());
+  return content::WebUIFactory::Get()->GetWebUIType(context(), GetURL());
 }
 
 void TabContents::DidNavigateMainFramePostCommit(
     const content::LoadCommittedDetails& details,
     const ViewHostMsg_FrameNavigate_Params& params) {
   if (opener_web_ui_type_ != WebUI::kNoWebUI) {
     // If this is a window.open navigation, use the same WebUI as the renderer
     // that opened the window, as long as both renderers have the same
     // privileges.
     if (delegate_ && opener_web_ui_type_ == GetWebUITypeForCurrentState()) {
@@ skipping 167 matching lines @@
 
 RenderViewHostDelegate::View* TabContents::GetViewDelegate() {
   return view_.get();
 }
 
 RenderViewHostDelegate::RendererManagement*
 TabContents::GetRendererManagementDelegate() {
   return &render_manager_;
 }
 
-RendererPreferences TabContents::GetRendererPrefs(Profile* profile) const {
+RendererPreferences TabContents::GetRendererPrefs(
+    content::BrowserContext* context) const {
   return renderer_preferences_;
 }
 
 TabContents* TabContents::GetAsTabContents() {
   return this;
 }
 
 ViewType::Type TabContents::GetRenderViewType() const {
   return ViewType::TAB_CONTENTS;
 }
@@ skipping 354 matching lines @@
   is_showing_before_unload_dialog_ = true;
   delegate_->GetJavaScriptDialogCreator()->RunBeforeUnloadDialog(
       this,
       message,
       reply_msg);
 }
 
 WebPreferences TabContents::GetWebkitPrefs() {
   WebPreferences web_prefs =
       content::GetContentClient()->browser()->GetWebkitPrefs(
-          render_view_host()->process()->profile(), false);
+          render_view_host()->process()->context(), false);
 
   // Force accelerated compositing and 2d canvas off for chrome:, about: and
   // chrome-devtools: pages.
   if (GetURL().SchemeIs(chrome::kChromeDevToolsScheme) ||
       GetURL().SchemeIs(chrome::kChromeUIScheme) ||
       GetURL().SchemeIs(chrome::kAboutScheme)) {
     web_prefs.accelerated_compositing_enabled = false;
     web_prefs.accelerated_2d_canvas_enabled = false;
   }
 
@@ skipping 185 matching lines @@
 }
 
 void TabContents::SwapInRenderViewHost(RenderViewHost* rvh) {
   render_manager_.SwapInRenderViewHost(rvh);
 }
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   rwh_view->SetSize(view()->GetContainerSize());
 }