blimp: Move compositing, input and render widget feature to client/core.

blimp/client/core/input/blimp_input_manager.cc

 // Copyright 2015 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 "blimp/client/feature/compositor/blimp_input_manager.h"
+#include "blimp/client/core/input/blimp_input_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
+#include "base/single_thread_task_runner.h"
+#include "base/synchronization/waitable_event.h"
+#include "blimp/client/core/input/blimp_input_handler_wrapper.h"
+#include "cc/input/input_handler.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/events/blink/blink_event_util.h"
 #include "ui/events/gesture_detection/gesture_provider_config_helper.h"
+#include "ui/events/gesture_detection/motion_event.h"
 
 namespace blimp {
 namespace client {
 
 std::unique_ptr<BlimpInputManager> BlimpInputManager::Create(
     BlimpInputManagerClient* client,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
     const base::WeakPtr<cc::InputHandler>& input_handler) {
   return base::WrapUnique(new BlimpInputManager(
       client, main_task_runner, compositor_task_runner, input_handler));
 }
 
 BlimpInputManager::BlimpInputManager(
     BlimpInputManagerClient* client,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
     const base::WeakPtr<cc::InputHandler>& input_handler)
     : client_(client),
       gesture_provider_(ui::GetGestureProviderConfig(
-                ui::GestureProviderConfigType::CURRENT_PLATFORM), this),
+                            ui::GestureProviderConfigType::CURRENT_PLATFORM),
+                        this),
       main_task_runner_(main_task_runner),
       compositor_task_runner_(compositor_task_runner),
       main_thread_blocked_(false),
       weak_factory_(this) {
   DCHECK(IsMainThread());
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &BlimpInputManager::CreateInputHandlerWrapperOnCompositorThread,
-          base::Unretained(this), weak_factory_.GetWeakPtr(),
-          input_handler));
+          base::Unretained(this), weak_factory_.GetWeakPtr(), input_handler));
 }
 
 BlimpInputManager::~BlimpInputManager() {
   DCHECK(IsMainThread());
 
   base::WaitableEvent shutdown_event(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   {
-    base::AutoReset<bool> auto_reset_main_thread_blocked(
-        &main_thread_blocked_, true);
+    base::AutoReset<bool> auto_reset_main_thread_blocked(&main_thread_blocked_,
+                                                         true);
     compositor_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &BlimpInputManager::ShutdownOnCompositorThread,
-            base::Unretained(this), &shutdown_event));
+        FROM_HERE, base::Bind(&BlimpInputManager::ShutdownOnCompositorThread,
+                              base::Unretained(this), &shutdown_event));
     shutdown_event.Wait();
   }
 }
 
 bool BlimpInputManager::OnTouchEvent(const ui::MotionEvent& motion_event) {
   DCHECK(IsMainThread());
 
   ui::FilteredGestureProvider::TouchHandlingResult result =
       gesture_provider_.OnTouchEvent(motion_event);
   if (!result.succeeded)
     return false;
 
-  blink::WebTouchEvent touch =
-      ui::CreateWebTouchEventFromMotionEvent(motion_event,
-                                             result.moved_beyond_slop_region);
+  blink::WebTouchEvent touch = ui::CreateWebTouchEventFromMotionEvent(
+      motion_event, result.moved_beyond_slop_region);
 
   // Touch events are queued in the Gesture Provider until acknowledged to
   // allow them to be consumed by the touch event handlers in blink which can
   // prevent-default on the event. Since we currently do not support touch
   // handlers the event is always acknowledged as not consumed.
   gesture_provider_.OnTouchEventAck(touch.uniqueTouchEventId, false);
 
   return true;
 }
 
@@ skipping 60 matching lines @@
 bool BlimpInputManager::IsMainThread() const {
   return main_task_runner_->BelongsToCurrentThread();
 }
 
 bool BlimpInputManager::IsCompositorThread() const {
   return compositor_task_runner_->BelongsToCurrentThread();
 }
 
 }  // namespace client
 }  // namespace blimp