Extract minimal RenderViewHost interface for embedders, leaving

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 345 matching lines @@
 #elif defined(OS_ANDROID)
   return new WebContentsViewAndroid(web_contents);
 #else
 #error Need to create your platform WebContentsView here.
 #endif
 }
 
 void ChromeContentBrowserClient::RenderViewHostCreated(
     RenderViewHost* render_view_host) {
 
-  SiteInstance* site_instance = render_view_host->site_instance();
+  SiteInstance* site_instance = render_view_host->GetSiteInstance();
   Profile* profile = Profile::FromBrowserContext(
       site_instance->GetBrowserContext());
 
   new ChromeRenderViewHostObserver(render_view_host,
                                    profile->GetNetworkPredictor());
   new ExtensionMessageHandler(render_view_host);
 
-  if (render_view_host->delegate()->GetRenderViewType() ==
+  if (render_view_host->GetDelegate()->GetRenderViewType() ==
       content::VIEW_TYPE_INTERSTITIAL_PAGE) {
     render_view_host->Send(new ChromeViewMsg_SetAsInterstitial(
-        render_view_host->routing_id()));
+        render_view_host->GetRoutingID()));
   }
 }
 
 void ChromeContentBrowserClient::RenderProcessHostCreated(
     content::RenderProcessHost* host) {
   int id = host->GetID();
   Profile* profile = Profile::FromBrowserContext(host->GetBrowserContext());
   host->GetChannel()->AddFilter(new ChromeRenderMessageFilter(
       id, profile, profile->GetRequestContextForRenderProcess(id)));
   host->GetChannel()->AddFilter(new PluginInfoMessageFilter(id, profile));
@@ skipping 755 matching lines @@
     int render_process_id,
     int render_view_id) {
 #if defined(ENABLE_NOTIFICATIONS)
   RenderViewHost* rvh = RenderViewHost::FromID(
       render_process_id, render_view_id);
   if (!rvh) {
     NOTREACHED();
     return;
   }
 
-  content::RenderProcessHost* process = rvh->process();
+  content::RenderProcessHost* process = rvh->GetProcess();
   Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
   DesktopNotificationService* service =
       DesktopNotificationServiceFactory::GetForProfile(profile);
   service->RequestPermission(
       source_origin, render_process_id, render_view_id, callback_context,
       tab_util::GetWebContentsByID(render_process_id, render_view_id));
 #else
   NOTIMPLEMENTED();
 #endif
 }
@@ skipping 27 matching lines @@
     int render_view_id,
     bool worker) {
 #if defined(ENABLE_NOTIFICATIONS)
   RenderViewHost* rvh = RenderViewHost::FromID(
       render_process_id, render_view_id);
   if (!rvh) {
     NOTREACHED();
     return;
   }
 
-  content::RenderProcessHost* process = rvh->process();
+  content::RenderProcessHost* process = rvh->GetProcess();
   Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
   DesktopNotificationService* service =
       DesktopNotificationServiceFactory::GetForProfile(profile);
   service->ShowDesktopNotification(
     params, render_process_id, render_view_id,
     worker ? DesktopNotificationService::WorkerNotification :
         DesktopNotificationService::PageNotification);
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 void ChromeContentBrowserClient::CancelDesktopNotification(
     int render_process_id,
     int render_view_id,
     int notification_id) {
 #if defined(ENABLE_NOTIFICATIONS)
   RenderViewHost* rvh = RenderViewHost::FromID(
       render_process_id, render_view_id);
   if (!rvh) {
     NOTREACHED();
     return;
   }
 
-  content::RenderProcessHost* process = rvh->process();
+  content::RenderProcessHost* process = rvh->GetProcess();
   Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
   DesktopNotificationService* service =
       DesktopNotificationServiceFactory::GetForProfile(profile);
   service->CancelDesktopNotification(
       render_process_id, render_view_id, notification_id);
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
@@ skipping 60 matching lines @@
 }
 
 bool ChromeContentBrowserClient::IsFastShutdownPossible() {
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   return !browser_command_line.HasSwitch(switches::kChromeFrame);
 }
 
 void ChromeContentBrowserClient::OverrideWebkitPrefs(
     RenderViewHost* rvh, const GURL& url, WebPreferences* web_prefs) {
   Profile* profile = Profile::FromBrowserContext(
-      rvh->process()->GetBrowserContext());
+      rvh->GetProcess()->GetBrowserContext());
   PrefService* prefs = profile->GetPrefs();
 
   web_prefs->standard_font_family =
       UTF8ToUTF16(prefs->GetString(prefs::kWebKitGlobalStandardFontFamily));
   web_prefs->fixed_font_family =
       UTF8ToUTF16(prefs->GetString(prefs::kWebKitGlobalFixedFontFamily));
   web_prefs->serif_font_family =
       UTF8ToUTF16(prefs->GetString(prefs::kWebKitGlobalSerifFontFamily));
   web_prefs->sans_serif_font_family =
       UTF8ToUTF16(prefs->GetString(prefs::kWebKitGlobalSansSerifFontFamily));
@@ skipping 99 matching lines @@
   if (web_prefs->default_encoding.empty()) {
     prefs->ClearPref(prefs::kGlobalDefaultCharset);
     web_prefs->default_encoding =
         prefs->GetString(prefs::kGlobalDefaultCharset);
   }
   DCHECK(!web_prefs->default_encoding.empty());
 
   ExtensionService* service = profile->GetExtensionService();
   if (service) {
     const Extension* extension = service->extensions()->GetByID(
-        rvh->site_instance()->GetSite().host());
+        rvh->GetSiteInstance()->GetSite().host());
     extension_webkit_preferences::SetPreferences(
-        extension, rvh->delegate()->GetRenderViewType(), web_prefs);
+        extension, rvh->GetDelegate()->GetRenderViewType(), web_prefs);
   }
 
-  if (rvh->delegate()->GetRenderViewType() == chrome::VIEW_TYPE_NOTIFICATION) {
+  if (rvh->GetDelegate()->GetRenderViewType() ==
+      chrome::VIEW_TYPE_NOTIFICATION) {
     web_prefs->allow_scripts_to_close_windows = true;
-  } else if (rvh->delegate()->GetRenderViewType() ==
+  } else if (rvh->GetDelegate()->GetRenderViewType() ==
              chrome::VIEW_TYPE_BACKGROUND_CONTENTS) {
     // Disable all kinds of acceleration for background pages.
     // See http://crbug.com/96005 and http://crbug.com/96006
     web_prefs->force_compositing_mode = false;
     web_prefs->accelerated_compositing_enabled = false;
     web_prefs->accelerated_2d_canvas_enabled = false;
     web_prefs->accelerated_video_enabled = false;
     web_prefs->accelerated_painting_enabled = false;
     web_prefs->accelerated_plugins_enabled = false;
   }
 
 #if defined(FILE_MANAGER_EXTENSION)
   // Override the default of suppressing HW compositing for WebUI pages for the
   // file manager, which is implemented using WebUI but wants HW acceleration
   // for video decode & render.
   if (url.spec() == chrome::kChromeUIFileManagerURL) {
     web_prefs->accelerated_compositing_enabled = true;
     web_prefs->accelerated_2d_canvas_enabled = true;
   }
 #endif
 }
 
 void ChromeContentBrowserClient::UpdateInspectorSetting(
     RenderViewHost* rvh, const std::string& key, const std::string& value) {
   content::BrowserContext* browser_context =
-      rvh->process()->GetBrowserContext();
+      rvh->GetProcess()->GetBrowserContext();
   DictionaryPrefUpdate update(
       Profile::FromBrowserContext(browser_context)->GetPrefs(),
       prefs::kWebKitInspectorSettings);
   DictionaryValue* inspector_settings = update.Get();
   inspector_settings->SetWithoutPathExpansion(key,
                                               Value::CreateStringValue(value));
 }
 
 void ChromeContentBrowserClient::ClearInspectorSettings(RenderViewHost* rvh) {
   content::BrowserContext* browser_context =
-      rvh->process()->GetBrowserContext();
+      rvh->GetProcess()->GetBrowserContext();
   Profile::FromBrowserContext(browser_context)->GetPrefs()->
       ClearPref(prefs::kWebKitInspectorSettings);
 }
 
 void ChromeContentBrowserClient::BrowserURLHandlerCreated(
     BrowserURLHandler* handler) {
   // Add the default URL handlers.
   handler->AddHandlerPair(&ExtensionWebUI::HandleChromeURLOverride,
                           BrowserURLHandler::null_handler());
   handler->AddHandlerPair(BrowserURLHandler::null_handler(),
                           &ExtensionWebUI::HandleChromeURLOverrideReverse);
 
   // about: handler. Must come before chrome: handler, since it will
   // rewrite about: urls to chrome: URLs and then expect chrome: to
   // actually handle them.
   handler->AddHandlerPair(&WillHandleBrowserAboutURL,
                           BrowserURLHandler::null_handler());
   // chrome: & friends.
   handler->AddHandlerPair(&HandleWebUI,
                           BrowserURLHandler::null_handler());
 }
 
 void ChromeContentBrowserClient::ClearCache(RenderViewHost* rvh) {
   Profile* profile = Profile::FromBrowserContext(
-      rvh->site_instance()->GetProcess()->GetBrowserContext());
+      rvh->GetSiteInstance()->GetProcess()->GetBrowserContext());
   BrowsingDataRemover* remover = new BrowsingDataRemover(profile,
       BrowsingDataRemover::EVERYTHING,
       base::Time());
   remover->Remove(BrowsingDataRemover::REMOVE_CACHE);
   // BrowsingDataRemover takes care of deleting itself when done.
 }
 
 void ChromeContentBrowserClient::ClearCookies(RenderViewHost* rvh) {
   Profile* profile = Profile::FromBrowserContext(
-      rvh->site_instance()->GetProcess()->GetBrowserContext());
+      rvh->GetSiteInstance()->GetProcess()->GetBrowserContext());
   BrowsingDataRemover* remover = new BrowsingDataRemover(profile,
       BrowsingDataRemover::EVERYTHING,
       base::Time());
   int remove_mask = BrowsingDataRemover::REMOVE_SITE_DATA;
   remover->Remove(remove_mask);
   // BrowsingDataRemover takes care of deleting itself when done.
 }
 
 FilePath ChromeContentBrowserClient::GetDefaultDownloadDirectory() {
   return download_util::GetDefaultDownloadDirectory();
@@ skipping 70 matching lines @@
 #if defined(USE_NSS)
 crypto::CryptoModuleBlockingPasswordDelegate*
     ChromeContentBrowserClient::GetCryptoPasswordDelegate(
         const GURL& url) {
   return browser::NewCryptoModuleBlockingDialogDelegate(
       browser::kCryptoModulePasswordKeygen, url.host());
 }
 #endif
 
 }  // namespace chrome