Revert of 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 158 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(float device_scale_factor,
                                         const ScreenInfo& screen_info) {
   base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
   cc::LayerTreeSettings settings = GenerateLayerTreeSettings(
       *cmd, compositor_deps_, device_scale_factor, screen_info);
 
   animation_host_ = cc::AnimationHost::CreateMainInstance();
@@ skipping 590 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