[DevTools] Migrate InputHandler from RenderWidgetHostImpl to RenderFrameHostImpl.

content/browser/devtools/protocol/input_handler.cc

 // Copyright 2014 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/browser/devtools/protocol/input_handler.h"
 
 #include <stddef.h>
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/output/compositor_frame_metadata.h"
+#include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/common/input/synthetic_tap_gesture_params.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/gfx/geometry/point.h"
 
 namespace content {
 namespace devtools {
@@ skipping 106 matching lines @@
 
 InputHandler::InputHandler()
     : host_(NULL),
       page_scale_factor_(1.0),
       weak_factory_(this) {
 }
 
 InputHandler::~InputHandler() {
 }
 
-void InputHandler::SetRenderWidgetHost(RenderWidgetHostImpl* host) {
+void InputHandler::SetRenderFrameHost(RenderFrameHostImpl* host) {
   host_ = host;
 }
 
 void InputHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
 void InputHandler::OnSwapCompositorFrame(
     const cc::CompositorFrameMetadata& frame_metadata) {
   page_scale_factor_ = frame_metadata.page_scale_factor;
@@ skipping 51 matching lines @@
   if (code) {
     event.domCode = static_cast<int>(
         ui::KeycodeConverter::CodeStringToDomCode(*code));
   }
 
   if (key) {
     event.domKey = static_cast<int>(
         ui::KeycodeConverter::KeyStringToDomKey(*key));
   }
 
-  if (!host_)
+  if (!host_ || !host_->GetRenderWidgetHost())
     return Response::ServerError("Could not connect to view");
 
-  host_->Focus();
-  host_->ForwardKeyboardEvent(event);
+  host_->GetRenderWidgetHost()->Focus();
+  host_->GetRenderWidgetHost()->ForwardKeyboardEvent(event);
   return Response::OK();
 }
 
 Response InputHandler::DispatchMouseEvent(
     const std::string& type,
     int x,
     int y,
     const int* modifiers,
     const double* timestamp,
     const std::string* button,
@@ skipping 11 matching lines @@
 
   event.x = x * page_scale_factor_;
   event.y = y * page_scale_factor_;
   event.windowX = x * page_scale_factor_;
   event.windowY = y * page_scale_factor_;
   event.globalX = x * page_scale_factor_;
   event.globalY = y * page_scale_factor_;
   event.clickCount = click_count ? *click_count : 0;
   event.pointerType = blink::WebPointerProperties::PointerType::Mouse;
 
-  if (!host_)
+  if (!host_ || !host_->GetRenderWidgetHost())
     return Response::ServerError("Could not connect to view");
 
-  host_->Focus();
-  host_->ForwardMouseEvent(event);
+  host_->GetRenderWidgetHost()->Focus();
+  host_->GetRenderWidgetHost()->ForwardMouseEvent(event);
   return Response::OK();
 }
 
 Response InputHandler::EmulateTouchFromMouseEvent(const std::string& type,
                                                   int x,
                                                   int y,
                                                   double timestamp,
                                                   const std::string& button,
                                                   double* delta_x,
                                                   double* delta_y,
@@ skipping 24 matching lines @@
 
   event->x = x;
   event->y = y;
   event->windowX = x;
   event->windowY = y;
   event->globalX = x;
   event->globalY = y;
   event->clickCount = click_count ? *click_count : 0;
   event->pointerType = blink::WebPointerProperties::PointerType::Touch;
 
-  if (!host_)
+  if (!host_ || !host_->GetRenderWidgetHost())
     return Response::ServerError("Could not connect to view");
 
   if (event->type == blink::WebInputEvent::MouseWheel)
-    host_->ForwardWheelEvent(wheel_event);
+    host_->GetRenderWidgetHost()->ForwardWheelEvent(wheel_event);
   else
-    host_->ForwardMouseEvent(mouse_event);
+    host_->GetRenderWidgetHost()->ForwardMouseEvent(mouse_event);
   return Response::OK();
 }
 
 Response InputHandler::SynthesizePinchGesture(
     DevToolsCommandId command_id,
     int x,
     int y,
     double scale_factor,
     const int* relative_speed,
     const std::string* gesture_source_type) {
-  if (!host_)
+  if (!host_ || !host_->GetRenderWidgetHost())
     return Response::ServerError("Could not connect to view");
 
   SyntheticPinchGestureParams gesture_params;
   const int kDefaultRelativeSpeed = 800;
 
   gesture_params.scale_factor = scale_factor;
   gesture_params.anchor = CssPixelsToPointF(x, y, page_scale_factor_);
   gesture_params.relative_pointer_speed_in_pixels_s =
       relative_speed ? *relative_speed : kDefaultRelativeSpeed;
 
   if (!StringToGestureSourceType(
       gesture_source_type ? *gesture_source_type : kGestureSourceTypeDefault,
       gesture_params.gesture_source_type)) {
     return Response::InvalidParams("gestureSourceType");
   }
 
-  host_->QueueSyntheticGesture(
+  host_->GetRenderWidgetHost()->QueueSyntheticGesture(
       SyntheticGesture::Create(gesture_params),
       base::Bind(&InputHandler::SendSynthesizePinchGestureResponse,
                  weak_factory_.GetWeakPtr(), command_id));
 
   return Response::OK();
 }
 
 Response InputHandler::SynthesizeScrollGesture(
     DevToolsCommandId command_id,
     int x,
     int y,
     const int* x_distance,
     const int* y_distance,
     const int* x_overscroll,
     const int* y_overscroll,
     const bool* prevent_fling,
     const int* speed,
     const std::string* gesture_source_type,
     const int* repeat_count,
     const int* repeat_delay_ms,
     const std::string* interaction_marker_name) {
-  if (!host_)
+  if (!host_ || !host_->GetRenderWidgetHost())
     return Response::ServerError("Could not connect to view");
 
   SyntheticSmoothScrollGestureParams gesture_params;
   const bool kDefaultPreventFling = true;
   const int kDefaultSpeed = 800;
 
   gesture_params.anchor = CssPixelsToPointF(x, y, page_scale_factor_);
   gesture_params.prevent_fling =
       prevent_fling ? *prevent_fling : kDefaultPreventFling;
   gesture_params.speed_in_pixels_s = speed ? *speed : kDefaultSpeed;
@@ skipping 30 matching lines @@
     int repeat_count,
     base::TimeDelta repeat_delay,
     std::string interaction_marker_name,
     DevToolsCommandId command_id) {
   if (!interaction_marker_name.empty()) {
     // TODO(alexclarke): Can we move this elsewhere? It doesn't really fit here.
     TRACE_EVENT_COPY_ASYNC_BEGIN0("benchmark", interaction_marker_name.c_str(),
                                   command_id.call_id);
   }
 
-  host_->QueueSyntheticGesture(
+  host_->GetRenderWidgetHost()->QueueSyntheticGesture(
       SyntheticGesture::Create(gesture_params),
       base::Bind(&InputHandler::OnScrollFinished, weak_factory_.GetWeakPtr(),
                  gesture_params, repeat_count, repeat_delay,
                  interaction_marker_name, command_id));
 }
 
 void InputHandler::OnScrollFinished(
     SyntheticSmoothScrollGestureParams gesture_params,
     int repeat_count,
     base::TimeDelta repeat_delay,
@@ skipping 17 matching lines @@
   }
 }
 
 Response InputHandler::SynthesizeTapGesture(
     DevToolsCommandId command_id,
     int x,
     int y,
     const int* duration,
     const int* tap_count,
     const std::string* gesture_source_type) {
-  if (!host_)
+  if (!host_ || !host_->GetRenderWidgetHost())
     return Response::ServerError("Could not connect to view");
 
   SyntheticTapGestureParams gesture_params;
   const int kDefaultDuration = 50;
   const int kDefaultTapCount = 1;
 
   gesture_params.position = CssPixelsToPointF(x, y, page_scale_factor_);
   gesture_params.duration_ms = duration ? *duration : kDefaultDuration;
 
   if (!StringToGestureSourceType(
       gesture_source_type ? *gesture_source_type : kGestureSourceTypeDefault,
       gesture_params.gesture_source_type)) {
     return Response::InvalidParams("gestureSourceType");
   }
 
   if (!tap_count)
     tap_count = &kDefaultTapCount;
 
   for (int i = 0; i < *tap_count; i++) {
     // If we're doing more than one tap, don't send the response to the client
     // until we've completed the last tap.
     bool is_last_tap = i == *tap_count - 1;
-    host_->QueueSyntheticGesture(
+    host_->GetRenderWidgetHost()->QueueSyntheticGesture(
         SyntheticGesture::Create(gesture_params),
         base::Bind(&InputHandler::SendSynthesizeTapGestureResponse,
                    weak_factory_.GetWeakPtr(), command_id, is_last_tap));
   }
 
   return Response::OK();
 }
 
 Response InputHandler::DispatchTouchEvent(
     const std::string& type,
@@ skipping 41 matching lines @@
   } else {
     client_->SendError(command_id,
                        Response::InternalError(base::StringPrintf(
                            "Synthetic tap failed, result was %d", result)));
   }
 }
 
 }  // namespace input
 }  // namespace devtools
 }  // namespace content