Removes code using mus client lib

ui/views/mus/window_manager_connection.cc

Index: ui/views/mus/window_manager_connection.cc
diff --git a/ui/views/mus/window_manager_connection.cc b/ui/views/mus/window_manager_connection.cc
deleted file mode 100644
index 16fae1a900501bb28349dd8ef4321c4f08417164..0000000000000000000000000000000000000000
--- a/ui/views/mus/window_manager_connection.cc
+++ /dev/null
@@ -1,235 +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 "ui/views/mus/window_manager_connection.h"
-
-#include <algorithm>
-#include <set>
-#include <utility>
-
-#include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
-#include "base/threading/thread_local.h"
-#include "services/service_manager/public/cpp/connection.h"
-#include "services/service_manager/public/cpp/connector.h"
-#include "services/ui/public/cpp/gpu/gpu.h"
-#include "services/ui/public/cpp/property_type_converters.h"
-#include "services/ui/public/cpp/window.h"
-#include "services/ui/public/cpp/window_property.h"
-#include "services/ui/public/cpp/window_tree_client.h"
-#include "services/ui/public/interfaces/event_matcher.mojom.h"
-#include "services/ui/public/interfaces/window_tree.mojom.h"
-#include "ui/aura/env.h"
-#include "ui/aura/mus/os_exchange_data_provider_mus.h"
-#include "ui/views/mus/clipboard_mus.h"
-#include "ui/views/mus/native_widget_mus.h"
-#include "ui/views/mus/pointer_watcher_event_router.h"
-#include "ui/views/mus/screen_mus.h"
-#include "ui/views/mus/surface_context_factory.h"
-#include "ui/views/pointer_watcher.h"
-#include "ui/views/views_delegate.h"
-
-namespace views {
-namespace {
-
-using WindowManagerConnectionPtr =
-    base::ThreadLocalPointer<views::WindowManagerConnection>;
-
-// Env is thread local so that aura may be used on multiple threads.
-base::LazyInstance<WindowManagerConnectionPtr>::Leaky lazy_tls_ptr =
-    LAZY_INSTANCE_INITIALIZER;
-
-// Recursively finds the deepest visible window from |windows| that contains
-// |screen_point|, when offsetting by the display origins from
-// |display_origins|.
-ui::Window* GetWindowFrom(const std::map<int64_t, gfx::Point>& display_origins,
-                          const std::vector<ui::Window*>& windows,
-                          const gfx::Point& screen_point) {
-  for (ui::Window* window : windows) {
-    if (!window->visible())
-      continue;
-
-    auto it = display_origins.find(window->display_id());
-    if (it == display_origins.end())
-      continue;
-
-    gfx::Rect bounds_in_screen = window->GetBoundsInRoot();
-    bounds_in_screen.Offset(it->second.x(), it->second.y());
-
-    if (bounds_in_screen.Contains(screen_point)) {
-      if (!window->children().empty()) {
-        ui::Window* child =
-            GetWindowFrom(display_origins, window->children(), screen_point);
-        if (child)
-          return child;
-      }
-
-      return window;
-    }
-  }
-  return nullptr;
-}
-
-aura::Window* GetAuraWindowFromUiWindow(ui::Window* window) {
-  if (!window)
-    return nullptr;
-  NativeWidgetMus* nw_mus = NativeWidgetMus::GetForWindow(window);
-  return nw_mus
-             ? static_cast<internal::NativeWidgetPrivate*>(nw_mus)
-                   ->GetNativeView()
-             : nullptr;
-}
-
-}  // namespace
-
-WindowManagerConnection::~WindowManagerConnection() {
-  // ~WindowTreeClient calls back to us (we're its delegate), destroy it while
-  // we are still valid.
-  client_.reset();
-  ui::OSExchangeDataProviderFactory::SetFactory(nullptr);
-  ui::Clipboard::DestroyClipboardForCurrentThread();
-  gpu_.reset();
-  lazy_tls_ptr.Pointer()->Set(nullptr);
-
-  if (ViewsDelegate::GetInstance()) {
-    ViewsDelegate::GetInstance()->set_native_widget_factory(
-        ViewsDelegate::NativeWidgetFactory());
-  }
-}
-
-// static
-std::unique_ptr<WindowManagerConnection> WindowManagerConnection::Create(
-    service_manager::Connector* connector,
-    const service_manager::Identity& identity,
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  DCHECK(!lazy_tls_ptr.Pointer()->Get());
-  WindowManagerConnection* connection =
-      new WindowManagerConnection(connector, identity, std::move(task_runner));
-  DCHECK(lazy_tls_ptr.Pointer()->Get());
-  return base::WrapUnique(connection);
-}
-
-// static
-WindowManagerConnection* WindowManagerConnection::Get() {
-  WindowManagerConnection* connection = lazy_tls_ptr.Pointer()->Get();
-  DCHECK(connection);
-  return connection;
-}
-
-// static
-bool WindowManagerConnection::Exists() {
-  return !!lazy_tls_ptr.Pointer()->Get();
-}
-
-ui::Window* WindowManagerConnection::NewTopLevelWindow(
-    const std::map<std::string, std::vector<uint8_t>>& properties) {
-  return client_->NewTopLevelWindow(&properties);
-}
-
-NativeWidget* WindowManagerConnection::CreateNativeWidgetMus(
-    const std::map<std::string, std::vector<uint8_t>>& props,
-    const Widget::InitParams& init_params,
-    internal::NativeWidgetDelegate* delegate) {
-  // TYPE_CONTROL widgets require a NativeWidgetAura. So we let this fall
-  // through, so that the default NativeWidgetPrivate::CreateNativeWidget() is
-  // used instead.
-  if (init_params.type == Widget::InitParams::TYPE_CONTROL)
-    return nullptr;
-  std::map<std::string, std::vector<uint8_t>> properties = props;
-  NativeWidgetMus::ConfigurePropertiesForNewWindow(init_params, &properties);
-  properties[ui::mojom::WindowManager::kAppID_Property] =
-      mojo::ConvertTo<std::vector<uint8_t>>(identity_.name());
-  return new NativeWidgetMus(delegate, NewTopLevelWindow(properties),
-                             ui::mojom::CompositorFrameSinkType::DEFAULT);
-}
-
-const std::set<ui::Window*>& WindowManagerConnection::GetRoots() const {
-  return client_->GetRoots();
-}
-
-WindowManagerConnection::WindowManagerConnection(
-    service_manager::Connector* connector,
-    const service_manager::Identity& identity,
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-    : connector_(connector), identity_(identity) {
-  lazy_tls_ptr.Pointer()->Set(this);
-
-  gpu_ = ui::Gpu::Create(connector, std::move(task_runner));
-  compositor_context_factory_ =
-      base::MakeUnique<views::SurfaceContextFactory>(gpu_.get());
-  aura::Env::GetInstance()->set_context_factory(
-      compositor_context_factory_.get());
-  client_ = base::MakeUnique<ui::WindowTreeClient>(this, nullptr, nullptr);
-  client_->ConnectViaWindowTreeFactory(connector_);
-
-  pointer_watcher_event_router_ =
-      base::MakeUnique<PointerWatcherEventRouter>(client_.get());
-
-  screen_ = base::MakeUnique<ScreenMus>(this);
-  screen_->Init(connector);
-
-  std::unique_ptr<ClipboardMus> clipboard = base::MakeUnique<ClipboardMus>();
-  clipboard->Init(connector);
-  ui::Clipboard::SetClipboardForCurrentThread(std::move(clipboard));
-
-  ui::OSExchangeDataProviderFactory::SetFactory(this);
-
-  ViewsDelegate::GetInstance()->set_native_widget_factory(base::Bind(
-      &WindowManagerConnection::CreateNativeWidgetMus,
-      base::Unretained(this),
-      std::map<std::string, std::vector<uint8_t>>()));
-}
-
-ui::Window* WindowManagerConnection::GetUiWindowAtScreenPoint(
-    const gfx::Point& point) {
-  std::map<int64_t, gfx::Point> display_origins;
-  for (const display::Display& d :
-       display::Screen::GetScreen()->GetAllDisplays())
-    display_origins[d.id()] = d.bounds().origin();
-
-  const std::set<ui::Window*>& roots = GetRoots();
-  std::vector<ui::Window*> windows;
-  std::copy(roots.begin(), roots.end(), std::back_inserter(windows));
-  return GetWindowFrom(display_origins, windows, point);
-}
-
-void WindowManagerConnection::OnEmbed(ui::Window* root) {}
-
-void WindowManagerConnection::OnLostConnection(ui::WindowTreeClient* client) {
-  DCHECK_EQ(client, client_.get());
-  client_.reset();
-}
-
-void WindowManagerConnection::OnEmbedRootDestroyed(ui::Window* root) {
-  // Not called for WindowManagerConnection as WindowTreeClient isn't created by
-  // way of an Embed().
-  NOTREACHED();
-}
-
-void WindowManagerConnection::OnPointerEventObserved(
-    const ui::PointerEvent& event,
-    ui::Window* target) {
-  pointer_watcher_event_router_->OnPointerEventObserved(event, target);
-}
-
-void WindowManagerConnection::OnWindowManagerFrameValuesChanged() {
-  if (client_)
-    NativeWidgetMus::NotifyFrameChanged(client_.get());
-}
-
-gfx::Point WindowManagerConnection::GetCursorScreenPoint() {
-  return client_->GetCursorScreenPoint();
-}
-
-aura::Window* WindowManagerConnection::GetWindowAtScreenPoint(
-    const gfx::Point& point) {
-  return GetAuraWindowFromUiWindow(GetUiWindowAtScreenPoint(point));
-}
-
-std::unique_ptr<OSExchangeData::Provider>
-WindowManagerConnection::BuildProvider() {
-  return base::MakeUnique<aura::OSExchangeDataProviderMus>();
-}
-
-}  // namespace views