Refactor the render widget unittest so it can be reused to create a render vi...

chrome/renderer/render_view.cc

 // Copyright (c) 2006-2008 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/render_view.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 71 matching lines @@
 // Delay in milliseconds that we'll wait before capturing the page contents
 // and thumbnail.
 static const int kDelayForCaptureMs = 500;
 
 // Typically, we capture the page data once the page is loaded.
 // Sometimes, the page never finishes to load, preventing the page capture
 // To workaround this problem, we always perform a capture after the following
 // delay.
 static const int kDelayForForcedCaptureMs = 6000;
 
-// How often we will sync the navigation state when the user is changing form
-// elements or scroll position.
-const TimeDelta kDelayForNavigationSync = TimeDelta::FromSeconds(5);
+// The default value for RenderView.delay_seconds_for_form_state_sync_, see
+// that variable for more.
+const int kDefaultDelaySecondsForFormStateSync = 5;
 
 // The next available page ID to use. This ensures that the page IDs are
 // globally unique in the renderer.
 static int32 next_page_id_ = 1;
 
 // The maximum number of popups that can be spawned from one page.
 static const int kMaximumNumberOfUnacknowledgedPopups = 25;
 
 static const char* const kUnreachableWebDataURL =
     "chrome://chromewebdata/";
@@ skipping 30 matching lines @@
  private:
   int32 pending_page_id_;
 
   DISALLOW_EVIL_CONSTRUCTORS(RenderViewExtraRequestData);
 };
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 
-RenderView::RenderView()
-  : RenderWidget(g_render_thread, true),
-    is_loading_(false),
-    page_id_(-1),
-    last_page_id_sent_to_browser_(-1),
-    last_indexed_page_id_(-1),
-    method_factory_(this),
-    opened_by_user_gesture_(true),
-    enable_dom_automation_(false),
-    enable_dom_ui_bindings_(false),
-    target_url_status_(TARGET_NONE),
-    printed_document_width_(0),
-    first_default_plugin_(NULL),
-    navigation_gesture_(NavigationGestureUnknown),
-    history_back_list_count_(0),
-    history_forward_list_count_(0),
-    disable_popup_blocking_(false),
-    has_unload_listener_(false),
-    decrement_shared_popup_at_destruction_(false),
-    greasemonkey_enabled_(false),
-    waiting_for_create_window_ack_(false),
-    form_field_autofill_request_id_(0),
-    popup_notification_visible_(false)  {
+RenderView::RenderView(RenderThreadBase* render_thread)
+    : RenderWidget(render_thread, true),
+      is_loading_(false),
+      page_id_(-1),
+      last_page_id_sent_to_browser_(-1),
+      last_indexed_page_id_(-1),
+      method_factory_(this),
+      opened_by_user_gesture_(true),
+      enable_dom_automation_(false),
+      enable_dom_ui_bindings_(false),
+      target_url_status_(TARGET_NONE),
+      printed_document_width_(0),
+      first_default_plugin_(NULL),
+      navigation_gesture_(NavigationGestureUnknown),
+      history_back_list_count_(0),
+      history_forward_list_count_(0),
+      disable_popup_blocking_(false),
+      has_unload_listener_(false),
+      decrement_shared_popup_at_destruction_(false),
+      greasemonkey_enabled_(false),
+      waiting_for_create_window_ack_(false),
+      form_field_autofill_request_id_(0),
+      popup_notification_visible_(false),
+      delay_seconds_for_form_state_sync_(kDefaultDelaySecondsForFormStateSync) {
   resource_dispatcher_ = new ResourceDispatcher(this);
 #ifdef CHROME_PERSONALIZATION
   personalization_ = Personalization::CreateRendererPersonalization();
 #endif
 }
 
 RenderView::~RenderView() {
   if (decrement_shared_popup_at_destruction_)
     shared_popup_counter_->data--;
 
   resource_dispatcher_->ClearMessageSender();
   // Clear any back-pointers that might still be held by plugins.
   PluginDelegateList::iterator it = plugin_delegates_.begin();
   while (it != plugin_delegates_.end()) {
     (*it)->DropRenderView();
     it = plugin_delegates_.erase(it);
   }
 
-  g_render_thread->RemoveFilter(debug_message_handler_);
+  render_thread_->RemoveFilter(debug_message_handler_);
 
 #ifdef CHROME_PERSONALIZATION
   Personalization::CleanupRendererPersonalization(personalization_);
   personalization_ = NULL;
 #endif
 }
 
 /*static*/
 RenderView* RenderView::Create(
+    RenderThreadBase* render_thread,
     HWND parent_hwnd,
     HANDLE modal_dialog_event,
     int32 opener_id,
     const WebPreferences& webkit_prefs,
     SharedRenderViewCounter* counter,
     int32 routing_id) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
-  scoped_refptr<RenderView> view = new RenderView();
+  scoped_refptr<RenderView> view = new RenderView(render_thread);
   view->Init(parent_hwnd,
              modal_dialog_event,
              opener_id,
              webkit_prefs,
              counter,
              routing_id);  // adds reference
   return view;
 }
 
 /*static*/
@@ skipping 50 matching lines @@
   // Avoid a leak here by not assigning, since WebView::Create addrefs for us.
   WebWidget* view = WebView::Create(this, webkit_prefs);
   webwidget_.swap(&view);
 
   // Don't let WebCore keep a B/F list - we have our own.
   // We let it keep 1 entry because FrameLoader::goToItem expects an item in the
   // backForwardList, which is used only in ASSERTs.
   webview()->SetBackForwardListSize(1);
 
   routing_id_ = routing_id;
-  g_render_thread->AddRoute(routing_id_, this);
+  render_thread_->AddRoute(routing_id_, this);
   // Take a reference on behalf of the RenderThread.  This will be balanced
   // when we receive ViewMsg_Close.
   AddRef();
 
   // If this is a popup, we must wait for the CreatingNew_ACK message before
   // completing initialization.  Otherwise, we can finish it now.
   if (opener_id == MSG_ROUTING_NONE) {
     did_show_ = true;
     CompleteInit(parent_hwnd);
   }
 
   host_window_ = parent_hwnd;
   modal_dialog_event_.Set(modal_dialog_event);
 
   CommandLine command_line;
   enable_dom_automation_ =
       command_line.HasSwitch(switches::kDomAutomationController);
   disable_popup_blocking_ =
       command_line.HasSwitch(switches::kDisablePopupBlocking);
   greasemonkey_enabled_ =
       command_line.HasSwitch(switches::kEnableGreasemonkey);
 
   debug_message_handler_ = new DebugMessageHandler(this);
-  g_render_thread->AddFilter(debug_message_handler_);
+  render_thread_->AddFilter(debug_message_handler_);
 }
 
 void RenderView::OnMessageReceived(const IPC::Message& message) {
   // If the current RenderView instance represents a popup, then we
   // need to wait for ViewMsg_CreatingNew_ACK to be sent by the browser.
   // As part of this ack we also receive the browser window handle, which
   // parents any plugins instantiated in this RenderView instance.
   // Plugins can be instantiated only when we receive the parent window
   // handle as they are child windows.
   if (waiting_for_create_window_ack_ && 
@@ skipping 1142 matching lines @@
 
 void RenderView::DidFinishDocumentLoadForFrame(WebView* webview,
                                                WebFrame* frame) {
   // Check whether we have new encoding name.
   UpdateEncoding(frame, webview->GetMainFrameEncodingName());
 
   // Inject any Greasemonkey scripts. Do not inject into chrome UI pages, but
   // do inject into any other document.
   if (greasemonkey_enabled_) {
     const GURL &gurl = frame->GetURL();
-    if (gurl.SchemeIs("file") ||
-        gurl.SchemeIs("http") ||
-        gurl.SchemeIs("https")) {
+    if (g_render_thread &&  // Will be NULL when testing.
+        (gurl.SchemeIs("file") ||
+         gurl.SchemeIs("http") ||
+         gurl.SchemeIs("https"))) {
       g_render_thread->greasemonkey_slave()->InjectScripts(frame);
     }
   }
 }
 
 void RenderView::DidHandleOnloadEventsForFrame(WebView* webview,
                                                WebFrame* frame) {
 }
 
 void RenderView::DidChangeLocationWithinPageForFrame(WebView* webview,
@@ skipping 304 matching lines @@
   // Check to make sure we aren't overloading on popups.
   if (shared_popup_counter_->data > kMaximumNumberOfUnacknowledgedPopups)
     return NULL;
 
   // This window can't be closed from a window.close() call until we receive a
   // message from the Browser process explicitly allowing it.
   popup_notification_visible_ = true;
 
   int32 routing_id = MSG_ROUTING_NONE;
   HANDLE modal_dialog_event = NULL;
-  bool result = g_render_thread->Send(
+  bool result = render_thread_->Send(
       new ViewHostMsg_CreateWindow(routing_id_, user_gesture, &routing_id,
                                    &modal_dialog_event));
   if (routing_id == MSG_ROUTING_NONE) {
     DCHECK(modal_dialog_event == NULL);
     return NULL;
   }
 
   // The WebView holds a reference to this new RenderView
   const WebPreferences& prefs = webview->GetPreferences();
-  RenderView* view = RenderView::Create(NULL, modal_dialog_event, routing_id_,
+  RenderView* view = RenderView::Create(render_thread_,
+                                        NULL, modal_dialog_event, routing_id_,
                                         prefs, shared_popup_counter_,
                                         routing_id);
   view->set_opened_by_user_gesture(user_gesture);
   view->set_waiting_for_create_window_ack(true);
 
   // Copy over the alternate error page URL so we can have alt error pages in
   // the new render view (we don't need the browser to send the URL back down).
   view->alternate_error_page_url_ = alternate_error_page_url_;
 
   return view->webview();
 }
 
 WebWidget* RenderView::CreatePopupWidget(WebView* webview,
                                          bool focus_on_show) {
   RenderWidget* widget = RenderWidget::Create(routing_id_,
-                                              g_render_thread,
+                                              render_thread_,
                                               focus_on_show);
   return widget->webwidget();
 }
 
 static bool ShouldLoadPluginInProcess(const std::string& mime_type,
                                       bool* is_gears) {
   if (RenderProcess::ShouldLoadPluginsInProcess())
     return true;
 
   if (mime_type == "application/x-googlegears") {
     *is_gears = true;
     CommandLine cmd;
     return cmd.HasSwitch(switches::kGearsInRenderer);
   }
 
   return false;
 }
 
 WebPluginDelegate* RenderView::CreatePluginDelegate(
     WebView* webview,
     const GURL& url,
     const std::string& mime_type,
     const std::string& clsid,
     std::string* actual_mime_type) {
   bool is_gears = false;
   if (ShouldLoadPluginInProcess(mime_type, &is_gears)) {
     std::wstring path;
-    g_render_thread->Send(
+    render_thread_->Send(
         new ViewHostMsg_GetPluginPath(url, mime_type, clsid, &path,
                                       actual_mime_type));
     if (path.empty())
       return NULL;
 
     std::string mime_type_to_use;
     if (actual_mime_type && !actual_mime_type->empty())
       mime_type_to_use = *actual_mime_type;
     else
       mime_type_to_use = mime_type;
@@ skipping 509 matching lines @@
 
 int RenderView::GetHistoryBackListCount() {
   return history_back_list_count_;
 }
 
 int RenderView::GetHistoryForwardListCount() {
   return history_forward_list_count_;
 }
 
 void RenderView::OnNavStateChanged(WebView* webview) {
-  if (!nav_state_sync_timer_.IsRunning())
-    nav_state_sync_timer_.Start(kDelayForNavigationSync, this,
-                                &RenderView::SyncNavigationState);
+  if (!nav_state_sync_timer_.IsRunning()) {
+    nav_state_sync_timer_.Start(
+        TimeDelta::FromSeconds(delay_seconds_for_form_state_sync_), this,
+        &RenderView::SyncNavigationState);
+  }
 }
 
 void RenderView::SetTooltipText(WebView* webview,
                                 const std::wstring& tooltip_text) {
   Send(new ViewHostMsg_SetTooltipText(routing_id_, tooltip_text));
 }
 
 void RenderView::DownloadUrl(const GURL& url, const GURL& referrer) {
   Send(new ViewHostMsg_DownloadUrl(routing_id_, url, referrer));
 }
@@ skipping 369 matching lines @@
           template_resource_id));
 
   if (template_html.empty()) {
     NOTREACHED() << "unable to load template. ID: " << template_resource_id;
     return "";
   }
   // "t" is the id of the templates root node.
   return jstemplate_builder::GetTemplateHtml(
       template_html, &error_strings, "t");
 }