Move compositor InputHandler from RenderViewImpl to RenderWidget.

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 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/gpu/render_widget_compositor.h"
 
 #include <stddef.h>
 
 #include <cmath>
 #include <limits>
@@ skipping 11 matching lines @@
 #include "base/sys_info.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/task_scheduler/task_scheduler.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_timeline.h"
+#include "cc/base/region.h"
 #include "cc/base/switches.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/debug/layer_tree_debug_state.h"
 #include "cc/debug/micro_benchmark.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/layers/layer.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/latency_info_swap_promise.h"
@@ skipping 155 matching lines @@
 }
 
 RenderWidgetCompositor::RenderWidgetCompositor(
     RenderWidgetCompositorDelegate* delegate,
     CompositorDependencies* compositor_deps)
     : num_failed_recreate_attempts_(0),
       delegate_(delegate),
       compositor_deps_(compositor_deps),
       threaded_(!!compositor_deps_->GetCompositorImplThreadTaskRunner()),
       never_visible_(false),
+      is_for_oopif_(false),
       layout_and_paint_async_callback_(nullptr),
       weak_factory_(this) {}
 
 void RenderWidgetCompositor::Initialize(
     std::unique_ptr<cc::LayerTreeHost> layer_tree_host,
     std::unique_ptr<cc::AnimationHost> animation_host) {
   DCHECK(layer_tree_host);
   DCHECK(animation_host);
   animation_host_ = std::move(animation_host);
   layer_tree_host_ = std::move(layer_tree_host);
@@ skipping 608 matching lines @@
               "EventListener and WebEventListener enums must match");
 
 void RenderWidgetCompositor::setEventListenerProperties(
     blink::WebEventListenerClass eventClass,
     blink::WebEventListenerProperties properties) {
   layer_tree_host_->GetLayerTree()->SetEventListenerProperties(
       static_cast<cc::EventListenerClass>(eventClass),
       static_cast<cc::EventListenerProperties>(properties));
 }
 
+void RenderWidgetCompositor::updateTouchRectsForSubframeIfNecessary() {
+  if (!is_for_oopif_)
+    return;
+
+  // If this is an oopif sub-frame compositor, we won't be getting TouchRects
+  // from ScrollingCoordinator, so to make sure touch events are handled
+  // properly, mark the entire root layer as a TouchRect.
+  // TODO(wjmaclean): remove this when ScrollingCoordinator is made per-frame,
+  // as opposed to per-page.
+  using blink::WebEventListenerProperties;
+  using blink::WebEventListenerClass;
+
+  blink::WebEventListenerProperties touch_start_properties =
+      eventListenerProperties(WebEventListenerClass::TouchStartOrMove);
+  blink::WebEventListenerProperties touch_end_cancel_properties =
+      eventListenerProperties(WebEventListenerClass::TouchEndOrCancel);
+  bool has_touch_handlers =
+      touch_start_properties == WebEventListenerProperties::Blocking ||
+      touch_start_properties ==
+          WebEventListenerProperties::BlockingAndPassive ||
+      touch_end_cancel_properties == WebEventListenerProperties::Blocking ||
+      touch_end_cancel_properties ==
+          WebEventListenerProperties::BlockingAndPassive;
+
+  cc::Layer* root_layer = layer_tree_host_->GetLayerTree()->root_layer();
+  cc::Region touch_handler_region;
+  if (has_touch_handlers)
+    touch_handler_region = gfx::Rect(gfx::Point(), root_layer->bounds());
+  root_layer->SetTouchEventHandlerRegion(touch_handler_region);
+}
+
 blink::WebEventListenerProperties
 RenderWidgetCompositor::eventListenerProperties(
     blink::WebEventListenerClass event_class) const {
   return static_cast<blink::WebEventListenerProperties>(
       layer_tree_host_->GetLayerTree()->event_listener_properties(
           static_cast<cc::EventListenerClass>(event_class)));
 }
 
 void RenderWidgetCompositor::setHaveScrollEventHandlers(bool has_handlers) {
   layer_tree_host_->GetLayerTree()->SetHaveScrollEventHandlers(has_handlers);
@@ skipping 251 matching lines @@
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
   layer_tree_host_->GetLayerTree()->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 void RenderWidgetCompositor::SetDeviceColorSpace(
     const gfx::ColorSpace& color_space) {
   layer_tree_host_->GetLayerTree()->SetDeviceColorSpace(color_space);
 }
 
+void RenderWidgetCompositor::SetIsForOopif(bool is_for_oopif) {
+  is_for_oopif_ = is_for_oopif;
+}
+
 }  // namespace content