mus: Remove the old client lib.

content/renderer/mus/compositor_mus_connection.cc

Index: content/renderer/mus/compositor_mus_connection.cc
diff --git a/content/renderer/mus/compositor_mus_connection.cc b/content/renderer/mus/compositor_mus_connection.cc
deleted file mode 100644
index 20386e8ca61233c4f3c65eb487fca6b557beccb1..0000000000000000000000000000000000000000
--- a/content/renderer/mus/compositor_mus_connection.cc
+++ /dev/null
@@ -1,237 +0,0 @@
-// 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 "content/renderer/mus/compositor_mus_connection.h"
-
-#include "base/memory/ptr_util.h"
-#include "base/single_thread_task_runner.h"
-#include "content/renderer/input/input_handler_manager.h"
-#include "content/renderer/mus/render_widget_mus_connection.h"
-#include "ui/events/blink/blink_event_util.h"
-#include "ui/events/blink/web_input_event.h"
-#include "ui/events/blink/web_input_event_traits.h"
-#include "ui/events/latency_info.h"
-#include "ui/events/mojo/event.mojom.h"
-
-using ui::mojom::EventResult;
-
-namespace {
-
-void DoNothingWithEventResult(EventResult result) {}
-
-gfx::Point GetScreenLocationFromEvent(const ui::LocatedEvent& event) {
-  return event.root_location();
-}
-
-}  // namespace
-
-namespace content {
-
-CompositorMusConnection::CompositorMusConnection(
-    int routing_id,
-    const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
-    const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
-    mojo::InterfaceRequest<ui::mojom::WindowTreeClient> request,
-    InputHandlerManager* input_handler_manager)
-    : routing_id_(routing_id),
-      root_(nullptr),
-      main_task_runner_(main_task_runner),
-      compositor_task_runner_(compositor_task_runner),
-      input_handler_manager_(input_handler_manager) {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
-  compositor_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&CompositorMusConnection::
-                                CreateWindowTreeClientOnCompositorThread,
-                            this, base::Passed(std::move(request))));
-}
-
-void CompositorMusConnection::AttachCompositorFrameSinkOnMainThread(
-    std::unique_ptr<ui::WindowCompositorFrameSinkBinding>
-        compositor_frame_sink_binding) {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
-  compositor_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &CompositorMusConnection::AttachCompositorFrameSinkOnCompositorThread,
-          this, base::Passed(std::move(compositor_frame_sink_binding))));
-}
-
-CompositorMusConnection::~CompositorMusConnection() {
-  base::AutoLock auto_lock(window_tree_client_lock_);
-  // Destruction must happen on the compositor task runner.
-  DCHECK(!window_tree_client_);
-}
-
-void CompositorMusConnection::AttachCompositorFrameSinkOnCompositorThread(
-    std::unique_ptr<ui::WindowCompositorFrameSinkBinding>
-        compositor_frame_sink_binding) {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  window_compositor_frame_sink_binding_ =
-      std::move(compositor_frame_sink_binding);
-  if (root_) {
-    root_->AttachCompositorFrameSink(
-        std::move(window_compositor_frame_sink_binding_));
-  }
-}
-
-void CompositorMusConnection::CreateWindowTreeClientOnCompositorThread(
-    mojo::InterfaceRequest<ui::mojom::WindowTreeClient> request) {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  DCHECK(!window_tree_client_);
-  std::unique_ptr<ui::WindowTreeClient> window_tree_client =
-      base::MakeUnique<ui::WindowTreeClient>(this, nullptr, std::move(request));
-  base::AutoLock auto_lock(window_tree_client_lock_);
-  window_tree_client_ = std::move(window_tree_client);
-}
-
-void CompositorMusConnection::OnConnectionLostOnMainThread() {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
-  RenderWidgetMusConnection* connection =
-      RenderWidgetMusConnection::Get(routing_id_);
-  if (!connection)
-    return;
-  connection->OnConnectionLost();
-}
-
-void CompositorMusConnection::OnWindowInputEventOnMainThread(
-    blink::WebScopedInputEvent web_event,
-    const base::Callback<void(EventResult)>& ack) {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
-  RenderWidgetMusConnection* connection =
-      RenderWidgetMusConnection::Get(routing_id_);
-  if (!connection) {
-    ack.Run(EventResult::UNHANDLED);
-    return;
-  }
-  connection->OnWindowInputEvent(std::move(web_event), ack);
-}
-
-void CompositorMusConnection::OnWindowInputEventAckOnMainThread(
-    const base::Callback<void(EventResult)>& ack,
-    EventResult result) {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
-  compositor_task_runner_->PostTask(FROM_HERE, base::Bind(ack, result));
-}
-
-std::unique_ptr<blink::WebInputEvent> CompositorMusConnection::Convert(
-    const ui::Event& event) {
-  if (event.IsMousePointerEvent()) {
-    const ui::MouseEvent mouse_event(*event.AsPointerEvent());
-    blink::WebMouseEvent blink_event = ui::MakeWebMouseEvent(
-        mouse_event, base::Bind(&GetScreenLocationFromEvent));
-    return base::MakeUnique<blink::WebMouseEvent>(blink_event);
-  } else if (event.IsTouchPointerEvent()) {
-    ui::TouchEvent touch_event(*event.AsPointerEvent());
-    pointer_state_.OnTouch(touch_event);
-    blink::WebTouchEvent blink_event = ui::CreateWebTouchEventFromMotionEvent(
-        pointer_state_, touch_event.may_cause_scrolling());
-    pointer_state_.CleanupRemovedTouchPoints(touch_event);
-    return base::MakeUnique<blink::WebTouchEvent>(blink_event);
-  } else if (event.IsMouseWheelEvent()) {
-    blink::WebMouseWheelEvent blink_event = ui::MakeWebMouseWheelEvent(
-        *event.AsMouseWheelEvent(), base::Bind(&GetScreenLocationFromEvent));
-    return base::MakeUnique<blink::WebMouseWheelEvent>(blink_event);
-  } else if (event.IsKeyEvent()) {
-    blink::WebKeyboardEvent blink_event =
-        ui::MakeWebKeyboardEvent(*event.AsKeyEvent());
-    return base::MakeUnique<blink::WebKeyboardEvent>(blink_event);
-  }
-  return nullptr;
-}
-
-void CompositorMusConnection::DeleteWindowTreeClient() {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  std::unique_ptr<ui::WindowTreeClient> window_tree_client;
-  {
-    base::AutoLock auto_lock(window_tree_client_lock_);
-    window_tree_client = std::move(window_tree_client_);
-  }
-  main_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&CompositorMusConnection::OnConnectionLostOnMainThread, this));
-}
-
-void CompositorMusConnection::OnEmbed(ui::Window* root) {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  root_ = root;
-  root_->set_input_event_handler(this);
-  if (window_compositor_frame_sink_binding_) {
-    root->AttachCompositorFrameSink(
-        std::move(window_compositor_frame_sink_binding_));
-  }
-}
-
-void CompositorMusConnection::OnEmbedRootDestroyed(ui::Window* window) {
-  DeleteWindowTreeClient();
-}
-
-void CompositorMusConnection::OnLostConnection(ui::WindowTreeClient* client) {
-  DeleteWindowTreeClient();
-}
-
-void CompositorMusConnection::OnPointerEventObserved(
-    const ui::PointerEvent& event,
-    ui::Window* target) {
-  // Compositor does not use StartPointerWatcher().
-}
-
-void CompositorMusConnection::OnWindowInputEvent(
-    ui::Window* window,
-    const ui::Event& event,
-    std::unique_ptr<base::Callback<void(EventResult)>>* ack_callback) {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-
-  // Take ownership of the callback, indicating that we will handle it.
-  std::unique_ptr<base::Callback<void(EventResult)>> callback =
-      std::move(*ack_callback);
-  blink::WebScopedInputEvent web_event(Convert(event).release());
-  // TODO(sad): We probably need to plumb LatencyInfo through Mus.
-  ui::LatencyInfo info;
-  input_handler_manager_->HandleInputEvent(
-      routing_id_, std::move(web_event), info,
-      base::Bind(
-          &CompositorMusConnection::DidHandleWindowInputEventAndOverscroll,
-          this, base::Passed(std::move(callback))));
-}
-
-void CompositorMusConnection::DidHandleWindowInputEventAndOverscroll(
-    std::unique_ptr<base::Callback<void(EventResult)>> ack_callback,
-    InputEventAckState ack_state,
-    blink::WebScopedInputEvent web_event,
-    const ui::LatencyInfo& latency_info,
-    std::unique_ptr<ui::DidOverscrollParams> overscroll_params) {
-  // TODO(jonross): We probably need to ack the event based on the consumed
-  // state.
-  if (ack_state != INPUT_EVENT_ACK_STATE_NOT_CONSUMED) {
-    // We took the ownership of the callback, so we need to send the ack, and
-    // mark the event as not consumed to preserve existing behavior.
-    ack_callback->Run(EventResult::UNHANDLED);
-    return;
-  }
-  base::Callback<void(EventResult)> ack =
-      base::Bind(&::DoNothingWithEventResult);
-  const bool send_ack =
-      ui::WebInputEventTraits::ShouldBlockEventStream(*web_event);
-  if (send_ack) {
-    // Ultimately, this ACK needs to go back to the Mus client lib which is not
-    // thread-safe and lives on the compositor thread. For ACKs that are passed
-    // to the main thread we pass them back to the compositor thread via
-    // OnWindowInputEventAckOnMainThread.
-    ack =
-        base::Bind(&CompositorMusConnection::OnWindowInputEventAckOnMainThread,
-                   this, *ack_callback);
-  } else {
-    // We took the ownership of the callback, so we need to send the ack, and
-    // mark the event as not consumed to preserve existing behavior.
-    ack_callback->Run(EventResult::UNHANDLED);
-  }
-  ack_callback.reset();
-
-  main_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&CompositorMusConnection::OnWindowInputEventOnMainThread, this,
-                 base::Passed(std::move(web_event)), ack));
-}
-
-}  // namespace content