Refactor RenderView creation to use ViewMsg_New_Params.

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/auto_reset.h"
@@ skipping 74 matching lines @@
 #include "content/renderer/internal_document_state_data.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/memory_benchmarking_extension.h"
 #include "content/renderer/mhtml_generator.h"
 #include "content/renderer/net_info_helper.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_frame_proxy.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
-#include "content/renderer/render_view_impl_params.h"
 #include "content/renderer/render_view_mouse_lock_dispatcher.h"
 #include "content/renderer/render_widget_fullscreen_pepper.h"
 #include "content/renderer/renderer_webapplicationcachehost_impl.h"
 #include "content/renderer/resizing_mode_selector.h"
 #include "content/renderer/savable_resources.h"
 #include "content/renderer/skia_benchmarking_extension.h"
 #include "content/renderer/speech_recognition_dispatcher.h"
 #include "content/renderer/stats_collection_controller.h"
 #include "content/renderer/stats_collection_observer.h"
 #include "content/renderer/text_input_client_observer.h"
@@ skipping 220 matching lines @@
 // better than having to wake up all renderers during shutdown.
 const int kDelaySecondsForContentStateSyncHidden = 5;
 const int kDelaySecondsForContentStateSync = 1;
 
 #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.
 const size_t kContentIntentDelayMilliseconds = 700;
 #endif
 
-static RenderViewImpl* (*g_create_render_view_impl)(RenderViewImplParams*) =
+static RenderViewImpl* (*g_create_render_view_impl)(const ViewMsg_New_Params&) =
     NULL;
 
 // static
 bool RenderViewImpl::IsReload(FrameMsg_Navigate_Type::Value navigation_type) {
   return navigation_type == FrameMsg_Navigate_Type::RELOAD ||
          navigation_type == FrameMsg_Navigate_Type::RELOAD_IGNORING_CACHE ||
          navigation_type == FrameMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL;
 }
 
 // static
@@ skipping 287 matching lines @@
     int32 script = u_getPropertyValueEnum(UCHAR_SCRIPT, (it->first).c_str());
     if (script >= 0 && script < USCRIPT_CODE_LIMIT) {
       UScriptCode code = static_cast<UScriptCode>(script);
       (*setter)(settings, it->second, GetScriptForWebSettings(code));
     }
   }
 }
 
 }  // namespace
 
-RenderViewImpl::RenderViewImpl(RenderViewImplParams* params)
+RenderViewImpl::RenderViewImpl(const ViewMsg_New_Params& params)
     : RenderWidget(blink::WebPopupTypeNone,
-                   params->initial_size.screen_info,
-                   params->swapped_out,
-                   params->hidden,
-                   params->never_visible),
-      webkit_preferences_(params->webkit_prefs),
+                   params.initial_size.screen_info,
+                   params.swapped_out,
+                   params.hidden,
+                   params.never_visible),
+      webkit_preferences_(params.web_preferences),
       send_content_state_immediately_(false),
       enabled_bindings_(0),
       send_preferred_size_changes_(false),
       navigation_gesture_(NavigationGestureUnknown),
       opened_by_user_gesture_(true),
       opener_suppressed_(false),
       suppress_dialogs_until_swap_out_(false),
       page_id_(-1),
       last_page_id_sent_to_browser_(-1),
-      next_page_id_(params->next_page_id),
+      next_page_id_(params.next_page_id),
       history_list_offset_(-1),
       history_list_length_(0),
       frames_in_progress_(0),
       target_url_status_(TARGET_NONE),
       uses_temporary_zoom_level_(false),
 #if defined(OS_ANDROID)
       top_controls_constraints_(cc::BOTH),
 #endif
       has_scrolled_focused_editable_node_into_rect_(false),
       speech_recognition_dispatcher_(NULL),
       browser_plugin_manager_(NULL),
       devtools_agent_(NULL),
       mouse_lock_dispatcher_(NULL),
 #if defined(OS_ANDROID)
       expected_content_intent_id_(0),
 #endif
 #if defined(OS_WIN)
       focused_plugin_id_(-1),
 #endif
 #if defined(ENABLE_PLUGINS)
       plugin_find_handler_(NULL),
       focused_pepper_plugin_(NULL),
       pepper_last_mouse_event_target_(NULL),
 #endif
       enumeration_completion_id_(0),
-      session_storage_namespace_id_(params->session_storage_namespace_id),
+      session_storage_namespace_id_(params.session_storage_namespace_id),
       next_snapshot_id_(0) {
 }
 
-void RenderViewImpl::Initialize(RenderViewImplParams* params) {
-  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;
+void RenderViewImpl::Initialize(
+    const ViewMsg_New_Params& params,
+    bool was_created_by_renderer) {
+  routing_id_ = params.view_id;
+  surface_id_ = params.surface_id;
+  if (params.opener_route_id != MSG_ROUTING_NONE && was_created_by_renderer)
+    opener_id_ = params.opener_route_id;
 
   // Ensure we start with a valid next_page_id_ from the browser.
   DCHECK_GE(next_page_id_, 0);
 
   main_render_frame_.reset(RenderFrameImpl::Create(
-      this, params->main_frame_routing_id));
+      this, params.main_frame_routing_id));
   // The main frame WebLocalFrame object is closed by
   // RenderFrameImpl::frameDetached().
   WebLocalFrame* web_frame = WebLocalFrame::create(main_render_frame_.get());
   main_render_frame_->SetWebFrame(web_frame);
 
   webwidget_ = WebView::create(this);
   webwidget_mouse_lock_target_.reset(new WebWidgetLockTarget(webwidget_));
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
@@ skipping 43 matching lines @@
       !command_line.HasSwitch(switches::kDisableThreadedScrolling));
   webview()->settings()->setRootLayerScrolls(
       command_line.HasSwitch(switches::kRootLayerScrolls));
 
   ApplyWebPreferences(webkit_preferences_, webview());
 
   webview()->settings()->setAllowConnectingInsecureWebSocket(
       command_line.HasSwitch(switches::kAllowInsecureWebSocketFromHttpsOrigin));
 
   RenderFrameProxy* proxy = NULL;
-  if (params->proxy_routing_id != MSG_ROUTING_NONE) {
-    CHECK(params->swapped_out);
+  if (params.proxy_routing_id != MSG_ROUTING_NONE) {
+    CHECK(params.swapped_out);
     proxy = RenderFrameProxy::CreateProxyToReplaceFrame(
-        main_render_frame_.get(), params->proxy_routing_id);
+        main_render_frame_.get(), params.proxy_routing_id);
     main_render_frame_->set_render_frame_proxy(proxy);
   }
 
   // In --site-per-process, just use the WebRemoteFrame as the main frame.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess) &&
       proxy) {
     webview()->setMainFrame(proxy->web_frame());
   } else {
     webview()->setMainFrame(main_render_frame_->GetWebFrame());
   }
   main_render_frame_->Initialize();
 
   if (switches::IsTouchDragDropEnabled())
     webview()->settings()->setTouchDragDropEnabled(true);
 
   if (switches::IsTouchEditingEnabled())
     webview()->settings()->setTouchEditingEnabled(true);
 
-  if (!params->frame_name.empty())
-    webview()->mainFrame()->setName(params->frame_name);
+  if (!params.frame_name.empty())
+    webview()->mainFrame()->setName(params.frame_name);
 
   // TODO(davidben): Move this state from Blink into content.
-  if (params->window_was_created_with_opener)
+  if (params.window_was_created_with_opener)
     webview()->setOpenedByDOM();
 
-  OnSetRendererPrefs(params->renderer_prefs);
+  OnSetRendererPrefs(params.renderer_preferences);
 
-  if (!params->enable_auto_resize) {
-    OnResize(params->initial_size);
+  if (!params.enable_auto_resize) {
+    OnResize(params.initial_size);
   } else {
-    OnEnableAutoResize(params->min_size, params->max_size);
+    OnEnableAutoResize(params.min_size, params.max_size);
   }
 
   new MHTMLGenerator(this);
 #if defined(OS_MACOSX)
   new TextInputClientObserver(this);
 #endif  // defined(OS_MACOSX)
 
   // The next group of objects all implement RenderViewObserver, so are deleted
   // along with the RenderView automatically.
   devtools_agent_ = new DevToolsAgent(this);
@@ skipping 10 matching lines @@
     enabled_bindings_ |= BINDINGS_POLICY_DOM_AUTOMATION;
   if (command_line.HasSwitch(switches::kStatsCollectionController))
     enabled_bindings_ |= BINDINGS_POLICY_STATS_COLLECTION;
 
   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 (params->opener_id != MSG_ROUTING_NONE && !params->is_renderer_created) {
-    RenderViewImpl* opener_view = FromRoutingID(params->opener_id);
+  if (params.opener_route_id != MSG_ROUTING_NONE && !was_created_by_renderer) {
+    RenderViewImpl* opener_view = FromRoutingID(params.opener_route_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_ && webview()->mainFrame()->isWebLocalFrame())
     main_render_frame_->NavigateToSwappedOutURL();
 }
 
@@ skipping 295 matching lines @@
 
   settings->setPinchOverlayScrollbarThickness(
       prefs.pinch_overlay_scrollbar_thickness);
   settings->setRubberBandingOnCompositorThread(
       prefs.rubber_banding_on_compositor_thread);
   settings->setUseSolidColorScrollbars(prefs.use_solid_color_scrollbars);
 }
 
 /*static*/
 RenderViewImpl* RenderViewImpl::Create(
-    int32 opener_id,
-    bool window_was_created_with_opener,
-    const RendererPreferences& renderer_prefs,
-    const WebPreferences& webkit_prefs,
-    int32 routing_id,
-    int32 main_frame_routing_id,
-    int32 surface_id,
-    int64 session_storage_namespace_id,
-    const base::string16& frame_name,
-    bool is_renderer_created,
-    bool swapped_out,
-    int32 proxy_routing_id,
-    bool hidden,
-    bool never_visible,
-    int32 next_page_id,
-    const ViewMsg_Resize_Params& initial_size,
-    bool enable_auto_resize,
-    const gfx::Size& min_size,
-    const gfx::Size& max_size) {
-  DCHECK(routing_id != MSG_ROUTING_NONE);
-  RenderViewImplParams params(opener_id,
-                              window_was_created_with_opener,
-                              renderer_prefs,
-                              webkit_prefs,
-                              routing_id,
-                              main_frame_routing_id,
-                              surface_id,
-                              session_storage_namespace_id,
-                              frame_name,
-                              is_renderer_created,
-                              swapped_out,
-                              proxy_routing_id,
-                              hidden,
-                              never_visible,
-                              next_page_id,
-                              initial_size,
-                              enable_auto_resize,
-                              min_size,
-                              max_size);
+    const ViewMsg_New_Params& params,
+    bool was_created_by_renderer) {
+  DCHECK(params.view_id != MSG_ROUTING_NONE);
   RenderViewImpl* render_view = NULL;
   if (g_create_render_view_impl)
-    render_view = g_create_render_view_impl(&params);
+    render_view = g_create_render_view_impl(params);
   else
-    render_view = new RenderViewImpl(&params);
+    render_view = new RenderViewImpl(params);
 
-  render_view->Initialize(&params);
+  render_view->Initialize(params, was_created_by_renderer);
   return render_view;
 }
 
 // static
 void RenderViewImpl::InstallCreateHook(
-    RenderViewImpl* (*create_render_view_impl)(RenderViewImplParams*)) {
+    RenderViewImpl* (*create_render_view_impl)(const ViewMsg_New_Params&)) {
   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();
@@ skipping 487 matching lines @@
   bool never_visible = false;
 
   ViewMsg_Resize_Params initial_size = ViewMsg_Resize_Params();
   initial_size.screen_info = screen_info_;
 
   // The initial hidden state for the RenderViewImpl here has to match what the
   // browser will eventually decide for the given disposition. Since we have to
   // return from this call synchronously, we just have to make our best guess
   // and rely on the browser sending a WasHidden / WasShown message if it
   // disagrees.
-  RenderViewImpl* view = RenderViewImpl::Create(
-      routing_id_,
-      true,  // window_was_created_with_opener
-      renderer_preferences_,
-      webkit_preferences_,
-      routing_id,
-      main_frame_routing_id,
-      surface_id,
-      cloned_session_storage_namespace_id,
-      base::string16(),  // WebCore will take care of setting the correct name.
-      true,              // is_renderer_created
-      false,             // swapped_out
-      MSG_ROUTING_NONE,  // proxy_routing_id
-      params.disposition == NEW_BACKGROUND_TAB,  // hidden
-      never_visible,
-      1,  // next_page_id
-      initial_size,
-      false, // enable_auto_resize
-      gfx::Size(), // min_size
-      gfx::Size() // max_size
-  );
+  ViewMsg_New_Params view_params;
+  view_params.opener_route_id = routing_id_;
+  view_params.window_was_created_with_opener = true;
+  view_params.renderer_preferences = renderer_preferences_;
+  view_params.web_preferences = webkit_preferences_;
+  view_params.view_id = routing_id;
+  view_params.main_frame_routing_id = main_frame_routing_id;
+  view_params.surface_id = surface_id;
+  view_params.session_storage_namespace_id =
+      cloned_session_storage_namespace_id;
+  // WebCore will take care of setting the correct name.
+  view_params.frame_name = base::string16();
+  view_params.swapped_out = false;
+  view_params.proxy_routing_id = MSG_ROUTING_NONE;
+  view_params.hidden = (params.disposition == NEW_BACKGROUND_TAB);
+  view_params.never_visible = never_visible;
+  view_params.next_page_id = 1;
+  view_params.initial_size = initial_size;
+  view_params.enable_auto_resize = false;
+  view_params.min_size = gfx::Size();
+  view_params.max_size = gfx::Size();
+
+  RenderViewImpl* view = RenderViewImpl::Create(view_params, true);
   view->opened_by_user_gesture_ = params.user_gesture;
 
   // Record whether the creator frame is trying to suppress the opener field.
   view->opener_suppressed_ = params.opener_suppressed;
 
   return view->webview();
 }
 
 WebWidget* RenderViewImpl::createPopupMenu(blink::WebPopupType popup_type) {
   RenderWidget* widget =
@@ skipping 2493 matching lines @@
     std::vector<gfx::Size> sizes;
     ConvertToFaviconSizes(icon_urls[i].sizes(), &sizes);
     if (!url.isEmpty())
       urls.push_back(
           FaviconURL(url, ToFaviconType(icon_urls[i].iconType()), sizes));
   }
   SendUpdateFaviconURL(urls);
 }
 
 }  // namespace content