RenderWidget: make routing_id be a parameter of the ctor

content/renderer/render_widget_unittest.cc

 // Copyright 2013 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 <tuple>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 35 matching lines @@
  public:
   MOCK_METHOD1(handleInputEvent,
                blink::WebInputEventResult(const blink::WebInputEvent&));
 };
 
 }  // namespace
 
 class InteractiveRenderWidget : public RenderWidget {
  public:
   explicit InteractiveRenderWidget(CompositorDependencies* compositor_deps)
-      : RenderWidget(compositor_deps,
+      : RenderWidget(++next_routing_id_,
+                     compositor_deps,
                      blink::WebPopupTypeNone,
                      ScreenInfo(),
                      false,
                      false,
                      false),
         always_overscroll_(false) {
-    webwidget_internal_ = &mock_webwidget_;
-    InitRoutingID(++next_routing_id_);
+    Init(MSG_ROUTING_NONE, mock_webwidget());
   }
 
   void SetTouchRegion(const std::vector<gfx::Rect>& rects) {
     rects_ = rects;
   }
 
   void SendInputEvent(const blink::WebInputEvent& event) {
     OnHandleInputEvent(
         &event, ui::LatencyInfo(),
         ui::WebInputEventTraits::ShouldBlockEventStream(event)
@@ skipping 52 matching lines @@
   static int next_routing_id_;
 
   DISALLOW_COPY_AND_ASSIGN(InteractiveRenderWidget);
 };
 
 int InteractiveRenderWidget::next_routing_id_ = 0;
 
 class RenderWidgetUnittest : public testing::Test {
  public:
   RenderWidgetUnittest()
-      : widget_(new InteractiveRenderWidget(&compositor_deps_)) {}
+      : widget_(new InteractiveRenderWidget(&compositor_deps_)) {
+    // RenderWidget::Init does an AddRef that's balanced by a browser-initiated
+    // Close IPC. That Close will never happen in this test, so do a Release
+    // here to ensure |widget_| is properly freed.
+    widget_->Release();
+    DCHECK(widget_->HasOneRef());
+  }
   ~RenderWidgetUnittest() override {}
 
   InteractiveRenderWidget* widget() const { return widget_.get(); }
 
   const base::HistogramTester& histogram_tester() const {
     return histogram_tester_;
   }
 
  private:
   MockRenderProcess render_process_;
@@ skipping 215 matching lines @@
   touch.MovePoint(0, 30, 30);
   touch.touchStartOrFirstTouchMove = false;
   widget()->SendInputEvent(touch);
   histogram_tester().ExpectTotalCount("Event.Touch.TouchLatencyOutsideFling",
                                       2);
 }
 
 class PopupRenderWidget : public RenderWidget {
  public:
   explicit PopupRenderWidget(CompositorDependencies* compositor_deps)
-      : RenderWidget(compositor_deps,
+      : RenderWidget(1,
+                     compositor_deps,
                      blink::WebPopupTypePage,
                      ScreenInfo(),
                      false,
                      false,
                      false) {
-    webwidget_internal_ = &mock_webwidget_;
-    InitRoutingID(1);
+    Init(MSG_ROUTING_NONE, mock_webwidget());
     did_show_ = true;
   }
 
   IPC::TestSink* sink() { return &sink_; }
 
   MockWebWidget* mock_webwidget() { return &mock_webwidget_; }
 
   void SetScreenMetricsEmulationParameters(
       bool,
       const blink::WebDeviceEmulationParams&) override {}
@@ skipping 10 matching lines @@
  private:
   IPC::TestSink sink_;
   MockWebWidget mock_webwidget_;
 
   DISALLOW_COPY_AND_ASSIGN(PopupRenderWidget);
 };
 
 class RenderWidgetPopupUnittest : public testing::Test {
  public:
   RenderWidgetPopupUnittest()
-      : widget_(new PopupRenderWidget(&compositor_deps_)) {}
+      : widget_(new PopupRenderWidget(&compositor_deps_)) {
+    // RenderWidget::Init does an AddRef that's balanced by a browser-initiated
+    // Close IPC. That Close will never happen in this test, so do a Release
+    // here to ensure |widget_| is properly freed.
+    widget_->Release();
+    DCHECK(widget_->HasOneRef());
+  }
   ~RenderWidgetPopupUnittest() override {}
 
   PopupRenderWidget* widget() const { return widget_.get(); }
   FakeCompositorDependencies compositor_deps_;
 
  private:
   MockRenderProcess render_process_;
   MockRenderThread render_thread_;
   scoped_refptr<PopupRenderWidget> widget_;
 
@@ skipping 20 matching lines @@
   emulation_params.viewPosition = blink::WebPoint(150, 160);
   emulation_params.fitToView = true;
 
   gfx::Rect parent_window_rect = gfx::Rect(0, 0, 800, 600);
 
   ResizeParams resize_params;
   resize_params.new_size = parent_window_rect.size();
 
   scoped_refptr<PopupRenderWidget> parent_widget(
       new PopupRenderWidget(&compositor_deps_));
+  parent_widget->Release();  // Balance Init().
   RenderWidgetScreenMetricsEmulator emulator(
       parent_widget.get(), emulation_params, resize_params, parent_window_rect,
       parent_window_rect);
   emulator.Apply();
 
   widget()->SetPopupOriginAdjustmentsForEmulation(&emulator);
 
   // Emulation-applied scale factor to fit the emulated device in the window.
   float scale =
       (float)parent_window_rect.height() / emulated_window_rect.height();
@@ skipping 23 matching lines @@
   blink::WebRect popup_emulated_rect(130, 170, 100, 400);
   widget()->setWindowRect(popup_emulated_rect);
 
   EXPECT_EQ(popup_emulated_rect.x, widget()->windowRect().x);
   EXPECT_EQ(popup_emulated_rect.y, widget()->windowRect().y);
   EXPECT_EQ(popup_emulated_rect.x, widget()->viewRect().x);
   EXPECT_EQ(popup_emulated_rect.y, widget()->viewRect().y);
 }
 
 }  // namespace content