Clear RenderThread of any Chrome specific code, and move a bunch of stuff out of RenderView.

chrome/renderer/chrome_content_renderer_client.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/renderer/chrome_content_renderer_client.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/path_service.h"
+#include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/child_process_logging.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_localization_peer.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/autofill/autofill_agent.h"
 #include "chrome/renderer/autofill/form_manager.h"
 #include "chrome/renderer/autofill/password_autofill_manager.h"
 #include "chrome/renderer/automation/automation_renderer_helper.h"
 #include "chrome/renderer/automation/dom_automation_v8_extension.h"
 #include "chrome/renderer/blocked_plugin.h"
-#include "chrome/renderer/chrome_render_observer.h"
+#include "chrome/renderer/chrome_render_process_observer.h"
+#include "chrome/renderer/chrome_render_view_observer.h"
 #include "chrome/renderer/devtools_agent.h"
 #include "chrome/renderer/devtools_agent_filter.h"
 #include "chrome/renderer/extensions/bindings_utils.h"
 #include "chrome/renderer/extensions/event_bindings.h"
 #include "chrome/renderer/extensions/extension_dispatcher.h"
 #include "chrome/renderer/extensions/extension_helper.h"
 #include "chrome/renderer/extensions/extension_process_bindings.h"
 #include "chrome/renderer/extensions/extension_resource_request_policy.h"
 #include "chrome/renderer/extensions/renderer_extension_bindings.h"
 #include "chrome/renderer/external_extension.h"
@@ skipping 18 matching lines @@
 #include "content/common/view_messages.h"
 #include "content/renderer/render_thread.h"
 #include "content/renderer/render_view.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/renderer_resources.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCache.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginParams.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityPolicy.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/app/breakpad_mac.h"
 #endif
 
 using autofill::AutofillAgent;
 using autofill::FormManager;
 using autofill::PasswordAutofillManager;
 using WebKit::WebCache;
 using WebKit::WebFrame;
 using WebKit::WebPlugin;
 using WebKit::WebPluginParams;
+using WebKit::WebSecurityPolicy;
 using WebKit::WebString;
 using WebKit::WebURLError;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
 using WebKit::WebVector;
 
 namespace {
 
 static const unsigned int kCacheStatsDelayMS = 2000 /* milliseconds */;
 
@@ skipping 113 matching lines @@
 
 namespace chrome {
 
 ChromeContentRendererClient::ChromeContentRendererClient() {
 }
 
 ChromeContentRendererClient::~ChromeContentRendererClient() {
 }
 
 void ChromeContentRendererClient::RenderThreadStarted() {
+  chrome_observer_.reset(new ChromeRenderProcessObserver());
   extension_dispatcher_.reset(new ExtensionDispatcher());
   histogram_snapshots_.reset(new RendererHistogramSnapshots());
   net_predictor_.reset(new RendererNetPredictor());
   spellcheck_.reset(new SpellCheck());
   visited_link_slave_.reset(new VisitedLinkSlave());
   phishing_classifier_.reset(new safe_browsing::PhishingClassifierFilter);
 
   RenderThread* thread = RenderThread::current();
   thread->AddFilter(new DevToolsAgentFilter());
 #if defined(OS_POSIX)
   thread->AddFilter(new SuicideOnChannelErrorFilter());
 #endif
 
+  thread->AddObserver(chrome_observer_.get());
   thread->AddObserver(extension_dispatcher_.get());
   thread->AddObserver(histogram_snapshots_.get());
   thread->AddObserver(phishing_classifier_.get());
   thread->AddObserver(spellcheck_.get());
   thread->AddObserver(visited_link_slave_.get());
 
   thread->RegisterExtension(extensions_v8::ExternalExtension::Get());
   thread->RegisterExtension(extensions_v8::LoadTimesExtension::Get());
   thread->RegisterExtension(extensions_v8::SearchBoxExtension::Get());
   v8::Extension* search_extension = extensions_v8::SearchExtension::Get();
   // search_extension is null if not enabled.
   if (search_extension)
     thread->RegisterExtension(search_extension);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDomAutomationController)) {
     thread->RegisterExtension(DomAutomationV8Extension::Get());
   }
 
   thread->resource_dispatcher()->set_observer(new RenderResourceObserver());
+
+  // chrome: pages should not be accessible by normal content, and should
+  // also be unable to script anything but themselves (to help limit the damage
+  // that a corrupt chrome: page could cause).
+  WebString chrome_ui_scheme(ASCIIToUTF16(chrome::kChromeUIScheme));
+  WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(chrome_ui_scheme);
+
+  // chrome-extension: resources shouldn't trigger insecure content warnings.
+  WebString extension_scheme(ASCIIToUTF16(chrome::kExtensionScheme));
+  WebSecurityPolicy::registerURLSchemeAsSecure(extension_scheme);
 }
 
 void ChromeContentRendererClient::RenderViewCreated(RenderView* render_view) {
   safe_browsing::PhishingClassifierDelegate* phishing_classifier = NULL;
 #ifndef OS_CHROMEOS
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableClientSidePhishingDetection)) {
     phishing_classifier =
         new safe_browsing::PhishingClassifierDelegate(render_view, NULL);
   }
@@ skipping 12 matching lines @@
   AutofillAgent* autofill_agent = new AutofillAgent(render_view,
                                                     password_autofill_manager);
   PageClickTracker* page_click_tracker = new PageClickTracker(render_view);
   // Note that the order of insertion of the listeners is important.
   // The password_autocomplete_manager takes the first shot at processing the
   // notification and can stop the propagation.
   page_click_tracker->AddListener(password_autofill_manager);
   page_click_tracker->AddListener(autofill_agent);
 
   TranslateHelper* translate = new TranslateHelper(render_view, autofill_agent);
-  new ChromeRenderObserver(render_view, translate, phishing_classifier);
+  new ChromeRenderViewObserver(render_view, translate, phishing_classifier);
 
   // Used only for testing/automation.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDomAutomationController)) {
     new AutomationRendererHelper(render_view);
   }
 }
 
 void ChromeContentRendererClient::SetNumberOfViews(int number_of_views) {
   child_process_logging::SetNumberOfViews(number_of_views);
@@ skipping 245 matching lines @@
   if (url.SchemeIs(chrome::kExtensionScheme) &&
       !ExtensionResourceRequestPolicy::CanRequestResource(
           url, GURL(frame->url()), extension_dispatcher_->extensions())) {
     *new_url = GURL("chrome-extension://invalid/");
     return true;
   }
 
   return false;
 }
 
+FilePath ChromeContentRendererClient::GetMediaLibraryPath() {
+  FilePath rv;
+  PathService::Get(chrome::DIR_MEDIA_LIBS, &rv);
+  return rv;
+}
+
+bool ChromeContentRendererClient::ShouldPumpEventsDuringCookieMessage() {
+  // We only need to pump events for chrome frame processes as the
+  // cookie policy is controlled by the host browser (IE). If the
+  // policy is set to prompt then the host would put up UI which
+  // would require plugins if any to also pump to ensure that we
+  // don't have a deadlock.
+  return CommandLine::ForCurrentProcess()->HasSwitch(switches::kChromeFrame);
+}
+
 void ChromeContentRendererClient::DidCreateScriptContext(WebFrame* frame) {
   EventBindings::HandleContextCreated(
       frame, false, extension_dispatcher_.get());
 }
 
 void ChromeContentRendererClient::DidDestroyScriptContext(WebFrame* frame) {
   EventBindings::HandleContextDestroyed(frame);
 }
 
 void ChromeContentRendererClient::DidCreateIsolatedScriptContext(
@@ skipping 29 matching lines @@
   if (old_url.is_empty() && frame->opener())
     old_url = frame->opener()->url();
 
   bool old_url_is_hosted_app = extensions->GetByURL(old_url) &&
       !extensions->GetByURL(old_url)->web_extent().is_empty();
   return !extensions->InSameExtent(old_url, new_url) &&
          !old_url_is_hosted_app;
 }
 
 }  // namespace chrome