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

chrome/renderer/chrome_render_view_observer.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_render_observer.h"
+#include "chrome/renderer/chrome_render_view_observer.h"
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/thumbnail_score.h"
+#include "chrome/renderer/about_handler.h"
 #include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
 #include "chrome/renderer/translate_helper.h"
+#include "content/common/view_messages.h"
 #include "content/renderer/content_renderer_client.h"
 #include "content/renderer/render_view.h"
 #include "skia/ext/bitmap_platform_device.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
@@ skipping 51 matching lines @@
 // bitmap are all the same brightness.
 static double CalculateBoringScore(SkBitmap* bitmap) {
   int histogram[256] = {0};
   color_utils::BuildLumaHistogram(bitmap, histogram);
 
   int color_count = *std::max_element(histogram, histogram + 256);
   int pixel_count = bitmap->width() * bitmap->height();
   return static_cast<double>(color_count) / pixel_count;
 }
 
-ChromeRenderObserver::ChromeRenderObserver(
+ChromeRenderViewObserver::ChromeRenderViewObserver(
     RenderView* render_view,
     TranslateHelper* translate_helper,
     safe_browsing::PhishingClassifierDelegate* phishing_classifier)
     : RenderViewObserver(render_view),
       translate_helper_(translate_helper),
       phishing_classifier_(phishing_classifier),
       last_indexed_page_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(page_info_method_factory_(this)) {
 }
 
-ChromeRenderObserver::~ChromeRenderObserver() {
+ChromeRenderViewObserver::~ChromeRenderViewObserver() {
 }
 
-bool ChromeRenderObserver::OnMessageReceived(const IPC::Message& message) {
+bool ChromeRenderViewObserver::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ChromeRenderObserver, message)
+  IPC_BEGIN_MESSAGE_MAP(ChromeRenderViewObserver, message)
     IPC_MESSAGE_HANDLER(ViewMsg_CaptureSnapshot, OnCaptureSnapshot)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
+
+  // Filter only.
+  IPC_BEGIN_MESSAGE_MAP(ChromeRenderViewObserver, message)
+    IPC_MESSAGE_HANDLER(ViewMsg_Navigate, OnNavigate)
+  IPC_END_MESSAGE_MAP()
+
   return handled;
 }
 
-void ChromeRenderObserver::OnCaptureSnapshot() {
+void ChromeRenderViewObserver::OnCaptureSnapshot() {
   SkBitmap snapshot;
   bool error = false;
 
   WebFrame* main_frame = render_view()->webview()->mainFrame();
   if (!main_frame)
     error = true;
 
   if (!error && !CaptureSnapshot(render_view()->webview(), &snapshot))
     error = true;
 
   DCHECK(error == snapshot.empty()) <<
       "Snapshot should be empty on error, non-empty otherwise.";
 
   // Send the snapshot to the browser process.
   Send(new ViewHostMsg_Snapshot(routing_id(), snapshot));
 }
 
-void ChromeRenderObserver::DidStopLoading() {
+void ChromeRenderViewObserver::OnNavigate(
+    const ViewMsg_Navigate_Params& params) {
+  AboutHandler::MaybeHandle(params.url);
+}
+
+void ChromeRenderViewObserver::DidStopLoading() {
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       page_info_method_factory_.NewRunnableMethod(
-          &ChromeRenderObserver::CapturePageInfo, render_view()->page_id(),
+          &ChromeRenderViewObserver::CapturePageInfo, render_view()->page_id(),
           false),
       render_view()->content_state_immediately() ? 0 : kDelayForCaptureMs);
 }
 
-void ChromeRenderObserver::DidCommitProvisionalLoad(WebFrame* frame,
-                                                    bool is_new_navigation) {
+void ChromeRenderViewObserver::DidCommitProvisionalLoad(
+    WebFrame* frame, bool is_new_navigation) {
   if (!is_new_navigation)
     return;
 
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       page_info_method_factory_.NewRunnableMethod(
-          &ChromeRenderObserver::CapturePageInfo, render_view()->page_id(),
+          &ChromeRenderViewObserver::CapturePageInfo, render_view()->page_id(),
           true),
       kDelayForForcedCaptureMs);
 }
 
-void ChromeRenderObserver::CapturePageInfo(int load_id,
-                                           bool preliminary_capture) {
+void ChromeRenderViewObserver::CapturePageInfo(int load_id,
+                                               bool preliminary_capture) {
   if (load_id != render_view()->page_id())
     return;  // This capture call is no longer relevant due to navigation.
 
   if (load_id == last_indexed_page_id_)
     return;  // we already indexed this page
 
   if (!render_view()->webview())
     return;
 
   WebFrame* main_frame = render_view()->webview()->mainFrame();
@@ skipping 35 matching lines @@
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableInBrowserThumbnailing)) {
     CaptureThumbnail();
   }
 
   // Will swap out the string.
   if (phishing_classifier_)
     phishing_classifier_->PageCaptured(&contents, preliminary_capture);
 }
 
-void ChromeRenderObserver::CaptureText(WebFrame* frame, string16* contents) {
+void ChromeRenderViewObserver::CaptureText(WebFrame* frame,
+                                           string16* contents) {
   contents->clear();
   if (!frame)
     return;
 
 #ifdef TIME_TEXT_RETRIEVAL
   double begin = time_util::GetHighResolutionTimeNow();
 #endif
 
   // get the contents of the frame
   *contents = frame->contentAsText(kMaxIndexChars);
@@ skipping 10 matching lines @@
   // partial word indexed at the end that might have been clipped. Therefore,
   // terminate the string at the last space to ensure no words are clipped.
   if (contents->size() == kMaxIndexChars) {
     size_t last_space_index = contents->find_last_of(kWhitespaceUTF16);
     if (last_space_index == std::wstring::npos)
       return;  // don't index if we got a huge block of text with no spaces
     contents->resize(last_space_index);
   }
 }
 
-void ChromeRenderObserver::CaptureThumbnail() {
+void ChromeRenderViewObserver::CaptureThumbnail() {
   WebFrame* main_frame = render_view()->webview()->mainFrame();
   if (!main_frame)
     return;
 
   // get the URL for this page
   GURL url(main_frame->url());
   if (url.is_empty())
     return;
 
   if (render_view()->size().IsEmpty())
     return;  // Don't create an empty thumbnail!
 
   ThumbnailScore score;
   SkBitmap thumbnail;
   if (!CaptureFrameThumbnail(render_view()->webview(), kThumbnailWidth,
                              kThumbnailHeight, &thumbnail, &score))
     return;
 
   // send the thumbnail message to the browser process
   Send(new ViewHostMsg_Thumbnail(routing_id(), url, score, thumbnail));
 }
 
-bool ChromeRenderObserver::CaptureFrameThumbnail(WebView* view,
-                                                 int w,
-                                                 int h,
-                                                 SkBitmap* thumbnail,
-                                                 ThumbnailScore* score) {
+bool ChromeRenderViewObserver::CaptureFrameThumbnail(WebView* view,
+                                                     int w,
+                                                     int h,
+                                                     SkBitmap* thumbnail,
+                                                     ThumbnailScore* score) {
   base::TimeTicks beginning_time = base::TimeTicks::Now();
 
   skia::PlatformCanvas canvas;
 
   // Paint |view| into |canvas|.
   if (!PaintViewIntoCanvas(view, canvas))
     return false;
 
   skia::BitmapPlatformDevice& device =
       static_cast<skia::BitmapPlatformDevice&>(canvas.getTopPlatformDevice());
@@ skipping 44 matching lines @@
       downsampled_subset, skia::ImageOperations::RESIZE_LANCZOS3, w, h);
 
   score->boring_score = CalculateBoringScore(thumbnail);
 
   HISTOGRAM_TIMES("Renderer4.Thumbnail",
                   base::TimeTicks::Now() - beginning_time);
 
   return true;
 }
 
-bool ChromeRenderObserver::CaptureSnapshot(WebView* view, SkBitmap* snapshot) {
+bool ChromeRenderViewObserver::CaptureSnapshot(WebView* view,
+                                               SkBitmap* snapshot) {
   base::TimeTicks beginning_time = base::TimeTicks::Now();
 
   skia::PlatformCanvas canvas;
   if (!PaintViewIntoCanvas(view, canvas))
     return false;
 
   skia::BitmapPlatformDevice& device =
       static_cast<skia::BitmapPlatformDevice&>(canvas.getTopPlatformDevice());
 
   const SkBitmap& bitmap = device.accessBitmap(false);
   if (!bitmap.copyTo(snapshot, SkBitmap::kARGB_8888_Config))
     return false;
 
   HISTOGRAM_TIMES("Renderer4.Snapshot",
                   base::TimeTicks::Now() - beginning_time);
   return true;
 }