Use the WebTestProxy for layout tests in content_shell

content/renderer/render_view_impl.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 "content/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 341 matching lines @@
 static const float kScalingIncrement = 0.1f;
 
 static const float kScalingIncrementForGesture = 0.01f;
 
 #if defined(OS_ANDROID)
 // Delay between tapping in content and launching the associated android intent.
 // Used to allow users see what has been recognized as content.
 static const size_t kContentIntentDelayMilliseconds = 700;
 #endif
 
+static RenderViewImpl* (*g_create_render_view_impl)(RenderViewImplParams*) =
+    NULL;
+
 static RenderViewImpl* FromRoutingID(int32 routing_id) {
   return static_cast<RenderViewImpl*>(
       ChildThread::current()->ResolveRoute(routing_id));
 }
 
 static WebKit::WebFrame* FindFrameByID(WebKit::WebFrame* root, int frame_id) {
   for (WebFrame* frame = root; frame; frame = frame->traverseNext(false)) {
     if (frame->identifier() == frame_id)
       return frame;
   }
@@ skipping 157 matching lines @@
     return -1;
 
   if (item.httpBody().isNull())
     return -1;
 
   return item.httpBody().identifier();
 }
 
 }  // namespace
 
-RenderViewImpl::RenderViewImpl(
+RenderViewImplParams::RenderViewImplParams(
     int32 opener_id,
     const RendererPreferences& renderer_prefs,
     const WebPreferences& webkit_prefs,
     SharedRenderViewCounter* counter,
     int32 routing_id,
     int32 surface_id,
     int64 session_storage_namespace_id,
     const string16& frame_name,
     bool is_renderer_created,
     bool swapped_out,
     int32 next_page_id,
     const WebKit::WebScreenInfo& screen_info,
     AccessibilityMode accessibility_mode)
-    : RenderWidget(WebKit::WebPopupTypeNone, screen_info, swapped_out),
-      webkit_preferences_(webkit_prefs),
+    : opener_id(opener_id),
+      renderer_prefs(renderer_prefs),
+      webkit_prefs(webkit_prefs),
+      counter(counter),
+      routing_id(routing_id),
+      surface_id(surface_id),
+      session_storage_namespace_id(session_storage_namespace_id),
+      frame_name(frame_name),
+      is_renderer_created(is_renderer_created),
+      swapped_out(swapped_out),
+      next_page_id(next_page_id),
+      screen_info(screen_info),
+      accessibility_mode(accessibility_mode) {
+}
+
+RenderViewImplParams::~RenderViewImplParams() {}
+
+RenderViewImpl::RenderViewImpl(RenderViewImplParams* params)
+    : RenderWidget(WebKit::WebPopupTypeNone,
+                   params->screen_info,
+                   params->swapped_out),
+      webkit_preferences_(params->webkit_prefs),
       send_content_state_immediately_(false),
       enabled_bindings_(0),
       send_preferred_size_changes_(false),
       is_loading_(false),
       navigation_gesture_(NavigationGestureUnknown),
       opened_by_user_gesture_(true),
       opener_suppressed_(false),
       page_id_(-1),
       last_page_id_sent_to_browser_(-1),
-      next_page_id_(next_page_id),
+      next_page_id_(params->next_page_id),
       history_list_offset_(-1),
       history_list_length_(0),
       target_url_status_(TARGET_NONE),
       selection_text_offset_(0),
       cached_is_main_frame_pinned_to_left_(false),
       cached_is_main_frame_pinned_to_right_(false),
       cached_has_main_frame_horizontal_scrollbar_(false),
       cached_has_main_frame_vertical_scrollbar_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(cookie_jar_(this)),
       geolocation_dispatcher_(NULL),
       input_tag_speech_dispatcher_(NULL),
       speech_recognition_dispatcher_(NULL),
       device_orientation_dispatcher_(NULL),
       media_stream_dispatcher_(NULL),
       media_stream_impl_(NULL),
       devtools_agent_(NULL),
       accessibility_mode_(AccessibilityModeOff),
       renderer_accessibility_(NULL),
       java_bridge_dispatcher_(NULL),
       mouse_lock_dispatcher_(NULL),
 #if defined(OS_ANDROID)
       body_background_color_(SK_ColorWHITE),
       update_frame_info_scheduled_(false),
       expected_content_intent_id_(0),
       media_player_proxy_(NULL),
       synchronous_find_active_match_ordinal_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           load_progress_tracker_(new LoadProgressTracker(this))),
 #endif
-      session_storage_namespace_id_(session_storage_namespace_id),
+      session_storage_namespace_id_(params->session_storage_namespace_id),
       handling_select_range_(false),
 #if defined(OS_WIN)
       focused_plugin_id_(-1),
 #endif
       updating_frame_tree_(false),
       pending_frame_tree_update_(false),
       target_process_id_(0),
       target_routing_id_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(pepper_delegate_(this)) {
-  set_throttle_input_events(renderer_prefs.throttle_input_events);
-  routing_id_ = routing_id;
-  surface_id_ = surface_id;
-  if (opener_id != MSG_ROUTING_NONE && is_renderer_created)
-    opener_id_ = opener_id;
+  set_throttle_input_events(params->renderer_prefs.throttle_input_events);
+  routing_id_ = params->routing_id;
+  surface_id_ = params->surface_id;
+  if (params->opener_id != MSG_ROUTING_NONE && params->is_renderer_created)
+    opener_id_ = params->opener_id;
 
   // Ensure we start with a valid next_page_id_ from the browser.
   DCHECK_GE(next_page_id_, 0);
 
 #if defined(ENABLE_NOTIFICATIONS)
   notification_provider_ = new NotificationProvider(this);
 #else
   notification_provider_ = NULL;
 #endif
 
@@ skipping 12 matching lines @@
           ? command_line.GetSwitchValueASCII(switches::kNetworkCountryIso)
           : device_info->GetNetworkCountryIso();
   content_detectors_.push_back(linked_ptr<ContentDetector>(
       new AddressDetector()));
   content_detectors_.push_back(linked_ptr<ContentDetector>(
       new PhoneNumberDetector(region_code)));
   content_detectors_.push_back(linked_ptr<ContentDetector>(
       new EmailDetector()));
 #endif
 
-  if (counter) {
-    shared_popup_counter_ = counter;
+  if (params->counter) {
+    shared_popup_counter_ = params->counter;
     // Only count this if it isn't swapped out upon creation.
-    if (!swapped_out)
+    if (!params->swapped_out)
       shared_popup_counter_->data++;
     decrement_shared_popup_at_destruction_ = true;
   } else {
     shared_popup_counter_ = new SharedRenderViewCounter(0);
     decrement_shared_popup_at_destruction_ = false;
   }
 
   RenderThread::Get()->AddRoute(routing_id_, this);
   // Take a reference on behalf of the RenderThread.  This will be balanced
   // when we receive ViewMsg_ClosePage.
   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();
   }
 
   g_view_map.Get().insert(std::make_pair(webview(), this));
   webview()->setDeviceScaleFactor(device_scale_factor_);
   webkit_preferences_.Apply(webview());
   webview()->initializeMainFrame(this);
-  if (!frame_name.empty())
-    webview()->mainFrame()->setName(frame_name);
+  if (!params->frame_name.empty())
+    webview()->mainFrame()->setName(params->frame_name);
   webview()->settings()->setMinimumTimerInterval(
       is_hidden() ? webkit_glue::kBackgroundTabTimerInterval :
           webkit_glue::kForegroundTabTimerInterval);
 
-  OnSetRendererPrefs(renderer_prefs);
+  OnSetRendererPrefs(params->renderer_prefs);
 
 #if defined(ENABLE_WEBRTC)
   if (!media_stream_dispatcher_)
     media_stream_dispatcher_ = new MediaStreamDispatcher(this);
 #endif
 
   new MHTMLGenerator(this);
 #if defined(OS_MACOSX)
   new TextInputClientObserver(this);
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_ANDROID)
   media_player_manager_.reset(
       new webkit_media::WebMediaPlayerManagerAndroid());
 #endif
 
   // The next group of objects all implement RenderViewObserver, so are deleted
   // along with the RenderView automatically.
   devtools_agent_ = new DevToolsAgent(this);
   mouse_lock_dispatcher_ = new RenderViewMouseLockDispatcher(this);
   intents_host_ = new WebIntentsHost(this);
 
   // Create renderer_accessibility_ if needed.
-  OnSetAccessibilityMode(accessibility_mode);
+  OnSetAccessibilityMode(params->accessibility_mode);
 
   new IdleUserDetector(this);
 
   if (command_line.HasSwitch(switches::kDomAutomationController))
     enabled_bindings_ |= BINDINGS_POLICY_DOM_AUTOMATION;
 
   ProcessViewLayoutFlags(command_line);
 
   GetContentClient()->renderer()->RenderViewCreated(this);
 
   // If we have an opener_id but we weren't created by a renderer, then
   // it's the browser asking us to set our opener to another RenderView.
-  if (opener_id != MSG_ROUTING_NONE && !is_renderer_created) {
-    RenderViewImpl* opener_view = FromRoutingID(opener_id);
+  if (params->opener_id != MSG_ROUTING_NONE && !params->is_renderer_created) {
+    RenderViewImpl* opener_view = FromRoutingID(params->opener_id);
     if (opener_view)
       webview()->mainFrame()->setOpener(opener_view->webview()->mainFrame());
   }
 
   // If we are initially swapped out, navigate to kSwappedOutURL.
   // This ensures we are in a unique origin that others cannot script.
   if (is_swapped_out_)
     NavigateToSwappedOutURL(webview()->mainFrame());
 }
 
@@ skipping 63 matching lines @@
     int32 routing_id,
     int32 surface_id,
     int64 session_storage_namespace_id,
     const string16& frame_name,
     bool is_renderer_created,
     bool swapped_out,
     int32 next_page_id,
     const WebKit::WebScreenInfo& screen_info,
     AccessibilityMode accessibility_mode) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
-  return new RenderViewImpl(
+  RenderViewImplParams params(
       opener_id,
       renderer_prefs,
       webkit_prefs,
       counter,
       routing_id,
       surface_id,
       session_storage_namespace_id,
       frame_name,
       is_renderer_created,
       swapped_out,
       next_page_id,
       screen_info,
       accessibility_mode);
+  if (g_create_render_view_impl)
+    return g_create_render_view_impl(&params);
+  return new RenderViewImpl(&params);
+}
+
+// static
+void RenderViewImpl::InstallCreateHook(
+    RenderViewImpl* (*create_render_view_impl)(RenderViewImplParams*)) {
+  CHECK(!g_create_render_view_impl);
+  g_create_render_view_impl = create_render_view_impl;
 }
 
 void RenderViewImpl::AddObserver(RenderViewObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void RenderViewImpl::RemoveObserver(RenderViewObserver* observer) {
   observer->RenderViewGone();
   observers_.RemoveObserver(observer);
 }
@@ skipping 5541 matching lines @@
 }
 #endif
 
 void RenderViewImpl::OnReleaseDisambiguationPopupDIB(
     TransportDIB::Handle dib_handle) {
   TransportDIB* dib = TransportDIB::CreateWithHandle(dib_handle);
   RenderProcess::current()->ReleaseTransportDIB(dib);
 }
 
 }  // namespace content