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

chrome/renderer/render_view.h

 // 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.
 
 #ifndef CHROME_RENDERER_RENDER_VIEW_H_
 #define CHROME_RENDERER_RENDER_VIEW_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/scoped_handle.h"
 #include "base/gfx/point.h"
 #include "base/gfx/rect.h"
 #include "base/timer.h"
 #include "base/values.h"
 #include "chrome/common/page_zoom.h"
 #include "chrome/common/resource_dispatcher.h"
 #ifdef CHROME_PERSONALIZATION
 #include "chrome/personalization/personalization.h"
 #endif
 #include "chrome/renderer/automation/dom_automation_controller.h"
 #include "chrome/renderer/dom_ui_bindings.h"
 #include "chrome/renderer/external_host_bindings.h"
 #include "chrome/renderer/external_js_object.h"
 #include "chrome/renderer/render_process.h"
 #include "chrome/renderer/render_widget.h"
+#include "testing/gtest/include/gtest/gtest_prod.h"
 #include "webkit/glue/console_message_level.h"
 #include "webkit/glue/dom_serializer_delegate.h"
 #include "webkit/glue/glue_accessibility.h"
 #include "webkit/glue/webview_delegate.h"
 #include "webkit/glue/webview.h"
 
 // RenderView is a diamond-shaped hierarchy, with WebWidgetDelegate at the root.
 // VS warns when we inherit the WebWidgetDelegate method implementations from
 // RenderWidget.  It's safe to ignore that warning.
 #pragma warning(disable: 4250)
 
 class DebugMessageHandler;
 class GURL;
+class RenderThread;
 class SkBitmap;
 struct ThumbnailScore;
 class WebError;
 class WebFrame;
 class WebPluginDelegate;
 class WebPluginDelegateProxy;
 enum WebRequestCachePolicy;
 
 namespace webkit_glue {
 struct FileUploadData;
@@ skipping 10 matching lines @@
 // kMaximumNumberOfPopups popups are created.
 //
 // This is a RefCounted holder of an int because I can't say
 // scoped_refptr<int>.
 typedef base::RefCountedData<int> SharedRenderViewCounter;
 
 //
 // RenderView is an object that manages a WebView object, and provides a
 // communication interface with an embedding application process
 //
-class RenderView : public RenderWidget, public WebViewDelegate,
+class RenderView : public RenderWidget,
+                   public WebViewDelegate,
                    public webkit_glue::DomSerializerDelegate {
  public:
   // Creates a new RenderView.  The parent_hwnd specifies a HWND to use as the
   // parent of the WebView HWND that will be created.  The modal_dialog_event
   // is set by the RenderView whenever a modal dialog alert is shown, so that
   // the renderer and plugin processes know to pump window messages.  If this
   // is a constrained popup or as a new tab, opener_id is the routing ID of the
   // RenderView responsible for creating this RenderView (corresponding to the
   // parent_hwnd). |counter| is either a currently initialized counter, or NULL
   // (in which case we treat this RenderView as a top level window).
   static RenderView* Create(
+      RenderThreadBase* render_thread,
       HWND parent_hwnd,
       HANDLE modal_dialog_event,
       int32 opener_id,
       const WebPreferences& webkit_prefs,
       SharedRenderViewCounter* counter,
       int32 routing_id);
 
   // Sets the "next page id" counter.
   static void SetNextPageID(int32 next_page_id);
 
@@ skipping 205 matching lines @@
   void SyncNavigationState();
 
   // Evaluates a string of JavaScript in a particular frame.
   void EvaluateScript(const std::wstring& frame_xpath,
                       const std::wstring& jscript);
 
   // Called when the Javascript debugger is no longer attached.
   // This is called from within the renderer, not via an IPC message.
   void OnDebugDetach();
 
+  int delay_seconds_for_form_state_sync() const {
+    return delay_seconds_for_form_state_sync_;
+  }
+  void set_delay_seconds_for_form_state_sync(int delay_in_seconds) {
+    delay_seconds_for_form_state_sync_ = delay_in_seconds;
+  }
+
  private:
-  RenderView();
+  FRIEND_TEST(RenderViewTest, OnLoadAlternateHTMLText);
+  FRIEND_TEST(RenderViewTest, OnNavStateChanged);
 
-  // When we are created from window.open from an already existing view, this
-  // constructor stores that view ID.
-  explicit RenderView(int32 opener_id);
+  explicit RenderView(RenderThreadBase* render_thread);
 
   // Initializes this view with the given parent and ID. The |routing_id| can be
   // set to 'MSG_ROUTING_NONE' if the true ID is not yet known. In this case,
   // CompleteInit must be called later with the true ID.
   void Init(HWND parent,
             HANDLE modal_dialog_event,
             int32 opener_id,
             const WebPreferences& webkit_prefs,
             SharedRenderViewCounter* counter,
             int32 routing_id);
@@ skipping 380 matching lines @@
 
   // We need to prevent windows from closing themselves with a window.close()
   // call while a blocked popup notification is being displayed. We cannot
   // synchronously querry the Browser process. We cannot wait for the Browser
   // process to send a message to us saying that a blocked popup notification
   // is being displayed. We instead assume that when we create a window off
   // this RenderView, that it is going to be blocked until we get a message
   // from the Browser process telling us otherwise.
   bool popup_notification_visible_;
 
+  // Time in seconds of the delay between syncing page state such as form
+  // elements and scroll position. This timeout allows us to avoid spamming the
+  // browser process with every little thing that changes. This normally doesn't
+  // change but is overridden by tests.
+  int delay_seconds_for_form_state_sync_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderView);
 };
 
 #endif  // CHROME_RENDERER_RENDER_VIEW_H_