RenderWidget: make routing_id be a parameter of the ctor

content/renderer/render_widget.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_widget.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 191 matching lines @@
       << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
   return static_cast<ui::TextInputMode>(mode);
 }
 
 }  // namespace
 
 namespace content {
 
 // RenderWidget ---------------------------------------------------------------
 
-RenderWidget::RenderWidget(CompositorDependencies* compositor_deps,
+RenderWidget::RenderWidget(int32_t widget_routing_id,
+                           CompositorDependencies* compositor_deps,
                            blink::WebPopupType popup_type,
                            const ScreenInfo& screen_info,
                            bool swapped_out,
                            bool hidden,
                            bool never_visible)
-    : routing_id_(MSG_ROUTING_NONE),
+    : routing_id_(widget_routing_id),
       compositor_deps_(compositor_deps),
       webwidget_internal_(nullptr),
       owner_delegate_(nullptr),
       opener_id_(MSG_ROUTING_NONE),
       next_paint_flags_(0),
       auto_resize_mode_(false),
       need_update_rect_for_auto_resize_(false),
       did_show_(false),
       is_hidden_(hidden),
       compositor_never_visible_(never_visible),
@@ skipping 19 matching lines @@
       monitor_composition_info_(false),
       popup_origin_scale_for_emulation_(0.f),
       frame_swap_message_queue_(new FrameSwapMessageQueue()),
       resizing_mode_selector_(new ResizingModeSelector()),
       has_host_context_menu_location_(false),
       has_focus_(false),
 #if defined(OS_MACOSX)
       text_input_client_observer_(new TextInputClientObserver(this)),
 #endif
       focused_pepper_plugin_(nullptr) {
+  DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
   if (!swapped_out)
     RenderProcess::current()->AddRefProcess();
   DCHECK(RenderThread::Get());
   device_color_profile_.push_back('0');
 #if defined(OS_ANDROID)
   text_input_info_history_.push_back(blink::WebTextInputInfo());
 #endif
 
   // In tests there may not be a RenderThreadImpl.
   if (RenderThreadImpl::current()) {
@@ skipping 28 matching lines @@
                                    const ScreenInfo& screen_info) {
   DCHECK(opener_id != MSG_ROUTING_NONE);
 
   // Do a synchronous IPC to obtain a routing ID.
   int32_t routing_id = MSG_ROUTING_NONE;
   if (!RenderThreadImpl::current_render_message_filter()->CreateNewWidget(
           opener_id, popup_type, &routing_id)) {
     return nullptr;
   }
 
-  scoped_refptr<RenderWidget> widget(new RenderWidget(
-      compositor_deps, popup_type, screen_info, false, false, false));
-  widget->InitRoutingID(routing_id);
+  scoped_refptr<RenderWidget> widget(
+      new RenderWidget(routing_id, compositor_deps, popup_type, screen_info,
+                       false, false, false));
   widget->Init(opener_id, RenderWidget::CreateWebWidget(widget.get()));
   DCHECK(!widget->HasOneRef());  // RenderWidget::Init() adds a reference.
   return widget.get();
 }
 
 // static
 RenderWidget* RenderWidget::CreateForFrame(
     int widget_routing_id,
     bool hidden,
     const ScreenInfo& screen_info,
     CompositorDependencies* compositor_deps,
     blink::WebLocalFrame* frame) {
   CHECK_NE(widget_routing_id, MSG_ROUTING_NONE);
   // TODO(avi): Before RenderViewImpl has-a RenderWidget, the browser passes the
   // same routing ID for both the view routing ID and the main frame widget
   // routing ID. https://crbug.com/545684
   RenderViewImpl* view = RenderViewImpl::FromRoutingID(widget_routing_id);
   if (view) {
     view->AttachWebFrameWidget(
         RenderWidget::CreateWebFrameWidget(view->GetWidget(), frame));
     return view->GetWidget();
   }
   scoped_refptr<RenderWidget> widget(
       g_create_render_widget
-          ? g_create_render_widget(compositor_deps, blink::WebPopupTypeNone,
-                                   screen_info, false, hidden, false)
-          : new RenderWidget(compositor_deps, blink::WebPopupTypeNone,
-                             screen_info, false, hidden, false));
+          ? g_create_render_widget(widget_routing_id, compositor_deps,
+                                   blink::WebPopupTypeNone, screen_info, false,
+                                   hidden, false)
+          : new RenderWidget(widget_routing_id, compositor_deps,
+                             blink::WebPopupTypeNone, screen_info, false,
+                             hidden, false));
   widget->for_oopif_ = true;
   // Init increments the reference count on |widget|, keeping it alive after
   // this function returns.
-  widget->InitRoutingID(widget_routing_id);
   widget->Init(MSG_ROUTING_NONE,
                RenderWidget::CreateWebFrameWidget(widget.get(), frame));
 
   if (g_render_widget_initialized)
     g_render_widget_initialized(widget.get());
   return widget.get();
 }
 
 // static
 blink::WebFrameWidget* RenderWidget::CreateWebFrameWidget(
@@ skipping 31 matching lines @@
 
   // If we are swapping out, we will call ReleaseProcess, allowing the process
   // to exit if all of its RenderViews are swapped out.  We wait until the
   // WasSwappedOut call to do this, to allow the unload handler to finish.
   // If we are swapping in, we call AddRefProcess to prevent the process from
   // exiting.
   if (!is_swapped_out_)
     RenderProcess::current()->AddRefProcess();
 }
 
-void RenderWidget::InitRoutingID(int32_t routing_id) {
-  DCHECK_EQ(routing_id_, MSG_ROUTING_NONE);
-  routing_id_ = routing_id;
+void RenderWidget::InitInputHandler() {
   input_handler_.reset(new RenderWidgetInputHandler(
       GetRenderWidgetInputHandlerDelegate(this), this));
 }
 
 void RenderWidget::Init(int32_t opener_id, WebWidget* web_widget) {
   DCHECK(!webwidget_internal_);
   DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
 
+  // Subclasses may pre-initialize |input_handler_|, but if not, make sure we
+  // have one now.
+  if (!input_handler_)
+    InitInputHandler();
+
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
   webwidget_internal_ = web_widget;
   webwidget_mouse_lock_target_.reset(
       new WebWidgetLockTarget(webwidget_internal_));
   mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
 
   RenderThread::Get()->AddRoute(routing_id_, this);
   // Take a reference on behalf of the RenderThread.  This will be balanced
@@ skipping 1673 matching lines @@
 blink::WebInputMethodController* RenderWidget::GetInputMethodController()
     const {
   // TODO(ekaramad): Remove this CHECK when GetWebWidget() is
   // always a WebFrameWidget.
   CHECK(GetWebWidget()->isWebFrameWidget());
   return static_cast<blink::WebFrameWidget*>(GetWebWidget())
       ->getActiveWebInputMethodController();
 }
 
 }  // namespace content