Removes code using mus client lib

ui/views/mus/native_widget_mus.cc

Index: ui/views/mus/native_widget_mus.cc
diff --git a/ui/views/mus/native_widget_mus.cc b/ui/views/mus/native_widget_mus.cc
deleted file mode 100644
index 7b6d929e5c03f271b6caf0a8baa3e3383eb2287b..0000000000000000000000000000000000000000
--- a/ui/views/mus/native_widget_mus.cc
+++ /dev/null
@@ -1,1589 +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.
-
-// This has to be before any other includes, else default is picked up.
-// See base/logging for details on this.
-#define NOTIMPLEMENTED_POLICY 5
-
-#include "ui/views/mus/native_widget_mus.h"
-
-#include <map>
-#include <utility>
-#include <vector>
-
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "services/ui/public/cpp/property_type_converters.h"
-#include "services/ui/public/cpp/window.h"
-#include "services/ui/public/cpp/window_observer.h"
-#include "services/ui/public/cpp/window_property.h"
-#include "services/ui/public/cpp/window_tree_client.h"
-#include "services/ui/public/interfaces/cursor.mojom.h"
-#include "services/ui/public/interfaces/window_manager.mojom.h"
-#include "services/ui/public/interfaces/window_manager_constants.mojom.h"
-#include "services/ui/public/interfaces/window_tree.mojom.h"
-#include "ui/aura/client/default_capture_client.h"
-#include "ui/aura/client/window_parenting_client.h"
-#include "ui/aura/layout_manager.h"
-#include "ui/aura/mus/mus_util.h"
-#include "ui/aura/mus/property_converter.h"
-#include "ui/aura/window.h"
-#include "ui/aura/window_property.h"
-#include "ui/base/hit_test.h"
-#include "ui/display/display.h"
-#include "ui/display/screen.h"
-#include "ui/events/event.h"
-#include "ui/gfx/canvas.h"
-#include "ui/gfx/geometry/dip_util.h"
-#include "ui/gfx/path.h"
-#include "ui/native_theme/native_theme.h"
-#include "ui/platform_window/platform_window_delegate.h"
-#include "ui/views/corewm/tooltip.h"
-#include "ui/views/corewm/tooltip_aura.h"
-#include "ui/views/corewm/tooltip_controller.h"
-#include "ui/views/drag_utils.h"
-#include "ui/views/mus/drag_drop_client_mus.h"
-#include "ui/views/mus/drop_target_mus.h"
-#include "ui/views/mus/input_method_mus.h"
-#include "ui/views/mus/window_manager_connection.h"
-#include "ui/views/mus/window_manager_constants_converters.h"
-#include "ui/views/mus/window_manager_frame_values.h"
-#include "ui/views/mus/window_tree_host_mus.h"
-#include "ui/views/widget/drop_helper.h"
-#include "ui/views/widget/native_widget_aura.h"
-#include "ui/views/widget/tooltip_manager_aura.h"
-#include "ui/views/widget/widget_delegate.h"
-#include "ui/views/window/custom_frame_view.h"
-#include "ui/wm/core/base_focus_rules.h"
-#include "ui/wm/core/capture_controller.h"
-#include "ui/wm/core/cursor_manager.h"
-#include "ui/wm/core/default_screen_position_client.h"
-#include "ui/wm/core/focus_controller.h"
-#include "ui/wm/core/native_cursor_manager.h"
-
-DECLARE_WINDOW_PROPERTY_TYPE(ui::Window*);
-
-using PrimitiveType = aura::PropertyConverter::PrimitiveType;
-using ui::mojom::EventResult;
-
-namespace views {
-namespace {
-
-DEFINE_WINDOW_PROPERTY_KEY(ui::Window*, kMusWindow, nullptr);
-
-MUS_DEFINE_WINDOW_PROPERTY_KEY(NativeWidgetMus*, kNativeWidgetMusKey, nullptr);
-
-// This ensures that only the top-level aura Window can be activated.
-class FocusRulesImpl : public wm::BaseFocusRules {
- public:
-  explicit FocusRulesImpl(aura::Window* root) : root_(root) {}
-  ~FocusRulesImpl() override {}
-
-  bool SupportsChildActivation(aura::Window* window) const override {
-    return root_ == window;
-  }
-
- private:
-  aura::Window* root_;
-
-  DISALLOW_COPY_AND_ASSIGN(FocusRulesImpl);
-};
-
-// This makes sure that an aura::Window focused (or activated) through the
-// aura::client::FocusClient (or ActivationClient) focuses (or activates) the
-// corresponding ui::Window too.
-class FocusControllerMus : public wm::FocusController {
- public:
-  explicit FocusControllerMus(wm::FocusRules* rules) : FocusController(rules) {}
-  ~FocusControllerMus() override {}
-
- private:
-  void FocusWindow(aura::Window* window) override {
-    FocusController::FocusWindow(window);
-    if (window) {
-      ui::Window* mus_window = window->GetRootWindow()->GetProperty(kMusWindow);
-      if (mus_window)
-        mus_window->SetFocus();
-    }
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(FocusControllerMus);
-};
-
-class ContentWindowLayoutManager : public aura::LayoutManager {
- public:
-  ContentWindowLayoutManager(aura::Window* outer, aura::Window* inner)
-      : outer_(outer), inner_(inner) {}
-  ~ContentWindowLayoutManager() override {}
-
- private:
-  // aura::LayoutManager:
-  void OnWindowResized() override { inner_->SetBounds(outer_->bounds()); }
-  void OnWindowAddedToLayout(aura::Window* child) override {
-    OnWindowResized();
-  }
-  void OnWillRemoveWindowFromLayout(aura::Window* child) override {}
-  void OnWindowRemovedFromLayout(aura::Window* child) override {}
-  void OnChildWindowVisibilityChanged(aura::Window* child,
-                                      bool visible) override {}
-  void SetChildBounds(aura::Window* child,
-                      const gfx::Rect& requested_bounds) override {
-    SetChildBoundsDirect(child, requested_bounds);
-  }
-
-  aura::Window* outer_;
-  aura::Window* inner_;
-
-  DISALLOW_COPY_AND_ASSIGN(ContentWindowLayoutManager);
-};
-
-class NativeWidgetMusWindowParentingClient
-    : public aura::client::WindowParentingClient {
- public:
-  explicit NativeWidgetMusWindowParentingClient(aura::Window* root_window)
-      : root_window_(root_window) {
-    aura::client::SetWindowParentingClient(root_window_, this);
-  }
-  ~NativeWidgetMusWindowParentingClient() override {
-    aura::client::SetWindowParentingClient(root_window_, nullptr);
-  }
-
-  // Overridden from client::WindowParentingClient:
-  aura::Window* GetDefaultParent(aura::Window* context,
-                                 aura::Window* window,
-                                 const gfx::Rect& bounds) override {
-    return root_window_;
-  }
-
- private:
-  aura::Window* root_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(NativeWidgetMusWindowParentingClient);
-};
-
-// A screen position client that applies the offset of the ui::Window.
-class ScreenPositionClientMus : public wm::DefaultScreenPositionClient {
- public:
-  explicit ScreenPositionClientMus(ui::Window* mus_window)
-      : mus_window_(mus_window) {}
-  ~ScreenPositionClientMus() override {}
-
-  // wm::DefaultScreenPositionClient:
-  void ConvertPointToScreen(const aura::Window* window,
-                            gfx::Point* point) override {
-    wm::DefaultScreenPositionClient::ConvertPointToScreen(window, point);
-    gfx::Rect mus_bounds = mus_window_->GetBoundsInRoot();
-    point->Offset(-mus_bounds.x(), -mus_bounds.y());
-  }
-  void ConvertPointFromScreen(const aura::Window* window,
-                              gfx::Point* point) override {
-    gfx::Rect mus_bounds = mus_window_->GetBoundsInRoot();
-    point->Offset(mus_bounds.x(), mus_bounds.y());
-    wm::DefaultScreenPositionClient::ConvertPointFromScreen(window, point);
-  }
-
- private:
-  ui::Window* mus_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScreenPositionClientMus);
-};
-
-class NativeCursorManagerMus : public wm::NativeCursorManager {
- public:
-  explicit NativeCursorManagerMus(ui::Window* mus_window)
-      : mus_window_(mus_window) {}
-  ~NativeCursorManagerMus() override {}
-
-  // wm::NativeCursorManager:
-  void SetDisplay(const display::Display& display,
-                  wm::NativeCursorManagerDelegate* delegate) override {
-    // We ignore this entirely, as cursor are set on the client.
-  }
-
-  void SetCursor(gfx::NativeCursor cursor,
-                 wm::NativeCursorManagerDelegate* delegate) override {
-    mus_window_->SetPredefinedCursor(ui::mojom::Cursor(cursor.native_type()));
-    delegate->CommitCursor(cursor);
-  }
-
-  void SetVisibility(bool visible,
-                     wm::NativeCursorManagerDelegate* delegate) override {
-    delegate->CommitVisibility(visible);
-
-    if (visible)
-      SetCursor(delegate->GetCursor(), delegate);
-    else
-      mus_window_->SetPredefinedCursor(ui::mojom::Cursor::NONE);
-  }
-
-  void SetCursorSet(ui::CursorSetType cursor_set,
-                    wm::NativeCursorManagerDelegate* delegate) override {
-    // TODO(erg): For now, ignore the difference between SET_NORMAL and
-    // SET_LARGE here. This feels like a thing that mus should decide instead.
-    //
-    // Also, it's NOTIMPLEMENTED() in the desktop version!? Including not
-    // acknowledging the call in the delegate.
-    NOTIMPLEMENTED();
-  }
-
-  void SetMouseEventsEnabled(
-      bool enabled,
-      wm::NativeCursorManagerDelegate* delegate) override {
-    // TODO(erg): How do we actually implement this?
-    //
-    // Mouse event dispatch is potentially done in a different process,
-    // definitely in a different mojo service. Each app is fairly locked down.
-    delegate->CommitMouseEventsEnabled(enabled);
-    NOTIMPLEMENTED();
-  }
-
- private:
-  ui::Window* mus_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(NativeCursorManagerMus);
-};
-
-// As the window manager renderers the non-client decorations this class does
-// very little but honor the client area insets from the window manager.
-class ClientSideNonClientFrameView : public NonClientFrameView {
- public:
-  explicit ClientSideNonClientFrameView(views::Widget* widget)
-      : widget_(widget) {}
-  ~ClientSideNonClientFrameView() override {}
-
- private:
-  // Returns the default values of client area insets from the window manager.
-  static gfx::Insets GetDefaultWindowManagerInsets(bool is_maximized) {
-    const WindowManagerFrameValues& values =
-        WindowManagerFrameValues::instance();
-    return is_maximized ? values.maximized_insets : values.normal_insets;
-  }
-
-  // NonClientFrameView:
-  gfx::Rect GetBoundsForClientView() const override {
-    gfx::Rect result(GetLocalBounds());
-    if (widget_->IsFullscreen())
-      return result;
-    result.Inset(GetDefaultWindowManagerInsets(widget_->IsMaximized()));
-    return result;
-  }
-  gfx::Rect GetWindowBoundsForClientBounds(
-      const gfx::Rect& client_bounds) const override {
-    if (widget_->IsFullscreen())
-      return client_bounds;
-
-    const gfx::Insets insets(
-        GetDefaultWindowManagerInsets(widget_->IsMaximized()));
-    return gfx::Rect(client_bounds.x() - insets.left(),
-                     client_bounds.y() - insets.top(),
-                     client_bounds.width() + insets.width(),
-                     client_bounds.height() + insets.height());
-  }
-  int NonClientHitTest(const gfx::Point& point) override { return HTNOWHERE; }
-  void GetWindowMask(const gfx::Size& size, gfx::Path* window_mask) override {
-    // The window manager provides the shape; do nothing.
-  }
-  void ResetWindowControls() override {
-    // TODO(sky): push to wm?
-  }
-
-  // These have no implementation. The Window Manager handles the actual
-  // rendering of the icon/title. See NonClientFrameViewMash. The values
-  // associated with these methods are pushed to the server by the way of
-  // NativeWidgetMus functions.
-  void UpdateWindowIcon() override {}
-  void UpdateWindowTitle() override {}
-  void SizeConstraintsChanged() override {}
-
-  gfx::Size GetPreferredSize() const override {
-    return widget_->non_client_view()
-        ->GetWindowBoundsForClientBounds(
-            gfx::Rect(widget_->client_view()->GetPreferredSize()))
-        .size();
-  }
-  gfx::Size GetMinimumSize() const override {
-    return widget_->non_client_view()
-        ->GetWindowBoundsForClientBounds(
-            gfx::Rect(widget_->client_view()->GetMinimumSize()))
-        .size();
-  }
-  gfx::Size GetMaximumSize() const override {
-    gfx::Size max_size = widget_->client_view()->GetMaximumSize();
-    gfx::Size converted_size =
-        widget_->non_client_view()
-            ->GetWindowBoundsForClientBounds(gfx::Rect(max_size))
-            .size();
-    return gfx::Size(max_size.width() == 0 ? 0 : converted_size.width(),
-                     max_size.height() == 0 ? 0 : converted_size.height());
-  }
-
-  views::Widget* widget_;
-
-  DISALLOW_COPY_AND_ASSIGN(ClientSideNonClientFrameView);
-};
-
-// Handles acknowledgment of an input event, either immediately when a nested
-// message loop starts, or upon destruction.
-class EventAckHandler : public base::MessageLoop::NestingObserver {
- public:
-  explicit EventAckHandler(
-      std::unique_ptr<base::Callback<void(EventResult)>> ack_callback)
-      : ack_callback_(std::move(ack_callback)) {
-    DCHECK(ack_callback_);
-    base::MessageLoop::current()->AddNestingObserver(this);
-  }
-
-  ~EventAckHandler() override {
-    base::MessageLoop::current()->RemoveNestingObserver(this);
-    if (ack_callback_) {
-      ack_callback_->Run(handled_ ? EventResult::HANDLED
-                                  : EventResult::UNHANDLED);
-    }
-  }
-
-  void set_handled(bool handled) { handled_ = handled; }
-
-  // base::MessageLoop::NestingObserver:
-  void OnBeginNestedMessageLoop() override {
-    // Acknowledge the event immediately if a nested message loop starts.
-    // Otherwise we appear unresponsive for the life of the nested message loop.
-    if (ack_callback_) {
-      ack_callback_->Run(EventResult::HANDLED);
-      ack_callback_.reset();
-    }
-  }
-
- private:
-  std::unique_ptr<base::Callback<void(EventResult)>> ack_callback_;
-  bool handled_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(EventAckHandler);
-};
-
-void OnMoveLoopEnd(bool* out_success,
-                   base::Closure quit_closure,
-                   bool in_success) {
-  *out_success = in_success;
-  quit_closure.Run();
-}
-
-ui::mojom::ShowState GetShowState(const ui::Window* window) {
-  if (!window ||
-      !window->HasSharedProperty(
-          ui::mojom::WindowManager::kShowState_Property)) {
-    return ui::mojom::ShowState::DEFAULT;
-  }
-
-  return static_cast<ui::mojom::ShowState>(
-      window->GetSharedProperty<PrimitiveType>(
-          ui::mojom::WindowManager::kShowState_Property));
-}
-
-// Set the app or window icon property for the window.
-void SetIconProperty(ui::Window* window,
-                     const char* const property,
-                     const gfx::ImageSkia& icon) {
-  // TODO(crbug.com/667566): Support additional scales or gfx::Image[Skia].
-  SkBitmap bitmap = icon.GetRepresentation(1.f).sk_bitmap();
-  if (!bitmap.isNull())
-    window->SetSharedProperty<SkBitmap>(property, bitmap);
-  else if (window->HasSharedProperty(property))
-    window->ClearSharedProperty(property);
-}
-
-// Helper function to get the device_scale_factor() of the display::Display
-// nearest to |window|.
-float ScaleFactorForDisplay(aura::Window* window) {
-  return display::Screen::GetScreen()
-      ->GetDisplayNearestWindow(window)
-      .device_scale_factor();
-}
-
-}  // namespace
-
-class NativeWidgetMus::MusWindowObserver : public ui::WindowObserver {
- public:
-  explicit MusWindowObserver(NativeWidgetMus* native_widget_mus)
-      : native_widget_mus_(native_widget_mus),
-        show_state_(ui::mojom::ShowState::DEFAULT) {
-    mus_window()->AddObserver(this);
-  }
-
-  ~MusWindowObserver() override {
-    mus_window()->RemoveObserver(this);
-  }
-
-  // ui::WindowObserver:
-  void OnWindowVisibilityChanging(ui::Window* window, bool visible) override {
-    native_widget_mus_->OnMusWindowVisibilityChanging(window, visible);
-  }
-  void OnWindowVisibilityChanged(ui::Window* window, bool visible) override {
-    native_widget_mus_->OnMusWindowVisibilityChanged(window, visible);
-  }
-  void OnWindowPredefinedCursorChanged(ui::Window* window,
-                                       ui::mojom::Cursor cursor) override {
-    DCHECK_EQ(window, mus_window());
-    native_widget_mus_->set_last_cursor(cursor);
-  }
-  void OnWindowSharedPropertyChanged(
-      ui::Window* window,
-      const std::string& name,
-      const std::vector<uint8_t>* old_data,
-      const std::vector<uint8_t>* new_data) override {
-    if (name != ui::mojom::WindowManager::kShowState_Property)
-      return;
-    const ui::mojom::ShowState show_state = GetShowState(window);
-    if (show_state == show_state_)
-      return;
-    show_state_ = show_state;
-    ui::PlatformWindowState state = ui::PLATFORM_WINDOW_STATE_UNKNOWN;
-    switch (show_state_) {
-      case ui::mojom::ShowState::MINIMIZED:
-        state = ui::PLATFORM_WINDOW_STATE_MINIMIZED;
-        break;
-      case ui::mojom::ShowState::MAXIMIZED:
-        state = ui::PLATFORM_WINDOW_STATE_MAXIMIZED;
-        break;
-      case ui::mojom::ShowState::DEFAULT:
-      case ui::mojom::ShowState::INACTIVE:
-      case ui::mojom::ShowState::NORMAL:
-      case ui::mojom::ShowState::DOCKED:
-        // TODO(sky): support docked.
-        state = ui::PLATFORM_WINDOW_STATE_NORMAL;
-        break;
-      case ui::mojom::ShowState::FULLSCREEN:
-        state = ui::PLATFORM_WINDOW_STATE_FULLSCREEN;
-        break;
-    }
-    platform_window_delegate()->OnWindowStateChanged(state);
-  }
-  void OnWindowDestroyed(ui::Window* window) override {
-    DCHECK_EQ(mus_window(), window);
-    platform_window_delegate()->OnClosed();
-  }
-  void OnWindowBoundsChanging(ui::Window* window,
-                              const gfx::Rect& old_bounds,
-                              const gfx::Rect& new_bounds) override {
-    DCHECK_EQ(window, mus_window());
-    window_tree_host()->SetBoundsInPixels(gfx::ConvertRectToPixel(
-        ScaleFactorForDisplay(aura_window()), new_bounds));
-  }
-  void OnWindowFocusChanged(ui::Window* gained_focus,
-                            ui::Window* lost_focus) override {
-    if (gained_focus == mus_window())
-      platform_window_delegate()->OnActivationChanged(true);
-    else if (lost_focus == mus_window())
-      platform_window_delegate()->OnActivationChanged(false);
-  }
-  void OnRequestClose(ui::Window* window) override {
-    platform_window_delegate()->OnCloseRequest();
-  }
-
- private:
-  ui::Window* mus_window() { return native_widget_mus_->window(); }
-  aura::Window* aura_window() { return native_widget_mus_->aura_window(); }
-  WindowTreeHostMus* window_tree_host() {
-    return native_widget_mus_->window_tree_host();
-  }
-  ui::PlatformWindowDelegate* platform_window_delegate() {
-    return native_widget_mus_->window_tree_host();
-  }
-
-  NativeWidgetMus* native_widget_mus_;
-  ui::mojom::ShowState show_state_;
-
-  DISALLOW_COPY_AND_ASSIGN(MusWindowObserver);
-};
-
-class NativeWidgetMus::MusCaptureClient
-    : public aura::client::DefaultCaptureClient {
- public:
-  MusCaptureClient(aura::Window* root_window,
-                   aura::Window* aura_window,
-                   ui::Window* mus_window)
-      : aura::client::DefaultCaptureClient(root_window),
-        aura_window_(aura_window),
-        mus_window_(mus_window) {}
-  ~MusCaptureClient() override {}
-
-  // aura::client::DefaultCaptureClient:
-  void SetCapture(aura::Window* window) override {
-    aura::client::DefaultCaptureClient::SetCapture(window);
-    if (aura_window_ == window)
-      mus_window_->SetCapture();
-  }
-  void ReleaseCapture(aura::Window* window) override {
-    aura::client::DefaultCaptureClient::ReleaseCapture(window);
-    if (aura_window_ == window)
-      mus_window_->ReleaseCapture();
-  }
-
- private:
-  aura::Window* aura_window_;
-  ui::Window* mus_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(MusCaptureClient);
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetMus, public:
-
-NativeWidgetMus::NativeWidgetMus(
-    internal::NativeWidgetDelegate* delegate,
-    ui::Window* window,
-    ui::mojom::CompositorFrameSinkType compositor_frame_sink_type)
-    : window_(window),
-      last_cursor_(ui::mojom::Cursor::CURSOR_NULL),
-      native_widget_delegate_(delegate),
-      compositor_frame_sink_type_(compositor_frame_sink_type),
-      show_state_before_fullscreen_(ui::mojom::ShowState::DEFAULT),
-      ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
-      content_(new aura::Window(this)),
-      last_drop_operation_(ui::DragDropTypes::DRAG_NONE),
-      close_widget_factory_(this) {
-  window_->set_input_event_handler(this);
-  mus_window_observer_ = base::MakeUnique<MusWindowObserver>(this);
-
-  // TODO(fsamuel): Figure out lifetime of |window_|.
-  aura::SetMusWindow(content_, window_);
-  window->SetLocalProperty(kNativeWidgetMusKey, this);
-  window_tree_host_ = base::MakeUnique<WindowTreeHostMus>(this, window_);
-  input_method_ =
-      base::MakeUnique<InputMethodMus>(window_tree_host_.get(), window_);
-  window_tree_host_->SetSharedInputMethod(input_method_.get());
-}
-
-NativeWidgetMus::~NativeWidgetMus() {
-  if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET) {
-    DCHECK(!window_);
-    delete native_widget_delegate_;
-  } else {
-    if (window_)
-      window_->set_input_event_handler(nullptr);
-    CloseNow();
-  }
-}
-
-// static
-void NativeWidgetMus::NotifyFrameChanged(ui::WindowTreeClient* client) {
-  for (ui::Window* window : client->GetRoots()) {
-    NativeWidgetMus* native_widget =
-        window->GetLocalProperty(kNativeWidgetMusKey);
-    if (native_widget && native_widget->GetWidget()->non_client_view()) {
-      native_widget->GetWidget()->non_client_view()->Layout();
-      native_widget->GetWidget()->non_client_view()->SchedulePaint();
-      native_widget->UpdateClientArea();
-      native_widget->UpdateHitTestMask();
-    }
-  }
-}
-
-// static
-NativeWidgetMus* NativeWidgetMus::GetForWindow(ui::Window* window) {
-  DCHECK(window);
-  NativeWidgetMus* native_widget =
-      window->GetLocalProperty(kNativeWidgetMusKey);
-  return native_widget;
-}
-
-// static
-Widget* NativeWidgetMus::GetWidgetForWindow(ui::Window* window) {
-  NativeWidgetMus* native_widget = GetForWindow(window);
-  if (!native_widget)
-    return nullptr;
-  return native_widget->GetWidget();
-}
-
-aura::Window* NativeWidgetMus::GetRootWindow() {
-  return window_tree_host_->window();
-}
-
-void NativeWidgetMus::OnPlatformWindowClosed() {
-  native_widget_delegate_->OnNativeWidgetDestroying();
-
-  tooltip_manager_.reset();
-  if (tooltip_controller_.get()) {
-    window_tree_host_->window()->RemovePreTargetHandler(
-        tooltip_controller_.get());
-    aura::client::SetTooltipClient(window_tree_host_->window(), NULL);
-    tooltip_controller_.reset();
-  }
-
-  window_parenting_client_.reset();  // Uses |content_|.
-  capture_client_.reset();      // Uses |content_|.
-
-  window_tree_host_->RemoveObserver(this);
-  window_tree_host_.reset();
-
-  cursor_manager_.reset();  // Uses |window_|.
-
-  mus_window_observer_.reset(nullptr);
-
-  window_ = nullptr;
-  content_ = nullptr;
-
-  native_widget_delegate_->OnNativeWidgetDestroyed();
-  if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
-    delete this;
-}
-
-void NativeWidgetMus::OnActivationChanged(bool active) {
-  if (!native_widget_delegate_)
-    return;
-  if (active) {
-    native_widget_delegate_->OnNativeFocus();
-    GetWidget()->GetFocusManager()->RestoreFocusedView();
-  } else {
-    native_widget_delegate_->OnNativeBlur();
-    GetWidget()->GetFocusManager()->StoreFocusedView(true);
-  }
-  native_widget_delegate_->OnNativeWidgetActivationChanged(active);
-}
-
-void NativeWidgetMus::UpdateClientArea() {
-  if (is_parallel_widget_in_window_manager())
-    return;
-
-  NonClientView* non_client_view =
-      native_widget_delegate_->AsWidget()->non_client_view();
-  if (!non_client_view || !non_client_view->client_view())
-    return;
-
-  const gfx::Rect client_area_rect(non_client_view->client_view()->bounds());
-  window_->SetClientArea(gfx::Insets(
-      client_area_rect.y(), client_area_rect.x(),
-      non_client_view->bounds().height() - client_area_rect.bottom(),
-      non_client_view->bounds().width() - client_area_rect.right()));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetMus, private:
-
-// static
-void NativeWidgetMus::ConfigurePropertiesForNewWindow(
-    const Widget::InitParams& init_params,
-    std::map<std::string, std::vector<uint8_t>>* properties) {
-  properties->insert(init_params.mus_properties.begin(),
-                     init_params.mus_properties.end());
-  if (!init_params.bounds.IsEmpty()) {
-    (*properties)[ui::mojom::WindowManager::kBounds_InitProperty] =
-        mojo::ConvertTo<std::vector<uint8_t>>(init_params.bounds);
-  }
-  if (!init_params.name.empty()) {
-    (*properties)[ui::mojom::WindowManager::kName_Property] =
-        mojo::ConvertTo<std::vector<uint8_t>>(init_params.name);
-  }
-  (*properties)[ui::mojom::WindowManager::kAlwaysOnTop_Property] =
-      mojo::ConvertTo<std::vector<uint8_t>>(
-          static_cast<PrimitiveType>(init_params.keep_on_top));
-
-  (*properties)[ui::mojom::WindowManager::kWindowType_InitProperty] =
-      mojo::ConvertTo<std::vector<uint8_t>>(
-          static_cast<int32_t>(init_params.type));
-
-  if (!Widget::RequiresNonClientView(init_params.type))
-    return;
-
-  if (init_params.delegate) {
-    if (properties->count(ui::mojom::WindowManager::kResizeBehavior_Property) ==
-        0) {
-      (*properties)[ui::mojom::WindowManager::kResizeBehavior_Property] =
-          mojo::ConvertTo<std::vector<uint8_t>>(static_cast<PrimitiveType>(
-              init_params.delegate->GetResizeBehavior()));
-    }
-
-    // TODO(crbug.com/667566): Support additional scales or gfx::Image[Skia].
-    gfx::ImageSkia app_icon = init_params.delegate->GetWindowAppIcon();
-    SkBitmap app_bitmap = app_icon.GetRepresentation(1.f).sk_bitmap();
-    if (!app_bitmap.isNull()) {
-      (*properties)[ui::mojom::WindowManager::kAppIcon_Property] =
-          mojo::ConvertTo<std::vector<uint8_t>>(app_bitmap);
-    }
-    // TODO(crbug.com/667566): Support additional scales or gfx::Image[Skia].
-    gfx::ImageSkia window_icon = init_params.delegate->GetWindowIcon();
-    SkBitmap window_bitmap = window_icon.GetRepresentation(1.f).sk_bitmap();
-    if (!window_bitmap.isNull()) {
-      (*properties)[ui::mojom::WindowManager::kWindowIcon_Property] =
-          mojo::ConvertTo<std::vector<uint8_t>>(window_bitmap);
-    }
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetMus, internal::NativeWidgetPrivate implementation:
-
-NonClientFrameView* NativeWidgetMus::CreateNonClientFrameView() {
-  return new ClientSideNonClientFrameView(GetWidget());
-}
-
-void NativeWidgetMus::InitNativeWidget(const Widget::InitParams& params) {
-  NativeWidgetAura::RegisterNativeWidgetForWindow(this, content_);
-  aura::Window* hosted_window = window_tree_host_->window();
-
-  ownership_ = params.ownership;
-  window_->SetCanFocus(params.activatable ==
-                       Widget::InitParams::ACTIVATABLE_YES);
-  window_->SetCanAcceptEvents(params.accept_events);
-
-  window_tree_host_->AddObserver(this);
-  window_tree_host_->InitHost();
-  window_tree_host_->window()->Show();
-  hosted_window->SetProperty(kMusWindow, window_);
-
-  // TODO(moshayedi): crbug.com/641039. Investigate whether there are any cases
-  // where we need input method but don't have the WindowManagerConnection here.
-  if (WindowManagerConnection::Exists())
-    input_method_->Init(WindowManagerConnection::Get()->connector());
-
-  focus_client_ =
-      base::MakeUnique<FocusControllerMus>(new FocusRulesImpl(hosted_window));
-
-  aura::client::SetFocusClient(hosted_window, focus_client_.get());
-  aura::client::SetActivationClient(hosted_window, focus_client_.get());
-  screen_position_client_ = base::MakeUnique<ScreenPositionClientMus>(window_);
-  aura::client::SetScreenPositionClient(hosted_window,
-                                        screen_position_client_.get());
-
-  drag_drop_client_ = base::MakeUnique<DragDropClientMus>(window_);
-  aura::client::SetDragDropClient(hosted_window, drag_drop_client_.get());
-  drop_target_ = base::MakeUnique<DropTargetMus>(content_);
-  window_->SetCanAcceptDrops(drop_target_.get());
-  drop_helper_ = base::MakeUnique<DropHelper>(GetWidget()->GetRootView());
-  aura::client::SetDragDropDelegate(content_, this);
-
-  if (params.type != Widget::InitParams::TYPE_TOOLTIP) {
-    tooltip_manager_ = base::MakeUnique<TooltipManagerAura>(GetWidget());
-    tooltip_controller_ = base::MakeUnique<corewm::TooltipController>(
-        base::MakeUnique<corewm::TooltipAura>());
-    aura::client::SetTooltipClient(window_tree_host_->window(),
-                                   tooltip_controller_.get());
-    window_tree_host_->window()->AddPreTargetHandler(tooltip_controller_.get());
-  }
-
-  // TODO(erg): Remove this check when ash/mus/move_event_handler.cc's
-  // direct usage of ui::Window::SetPredefinedCursor() is switched to a
-  // private method on WindowManagerClient.
-  if (!is_parallel_widget_in_window_manager()) {
-    cursor_manager_ = base::MakeUnique<wm::CursorManager>(
-        base::MakeUnique<NativeCursorManagerMus>(window_));
-    aura::client::SetCursorClient(hosted_window, cursor_manager_.get());
-  }
-
-  window_parenting_client_ =
-      base::MakeUnique<NativeWidgetMusWindowParentingClient>(hosted_window);
-  hosted_window->AddPreTargetHandler(focus_client_.get());
-  hosted_window->SetLayoutManager(
-      new ContentWindowLayoutManager(hosted_window, content_));
-  capture_client_ =
-      base::MakeUnique<MusCaptureClient>(hosted_window, content_, window_);
-
-  content_->SetType(ui::wm::WINDOW_TYPE_NORMAL);
-  content_->Init(params.layer_type);
-  if (window_->visible())
-    content_->Show();
-  content_->SetTransparent(true);
-  content_->SetFillsBoundsCompletely(false);
-  content_->set_ignore_events(!params.accept_events);
-  hosted_window->AddChild(content_);
-
-  ui::Window* parent_mus = params.parent_mus;
-
-  // Set-up transiency if appropriate.
-  if (params.parent && !params.child) {
-    aura::Window* parent_root_aura = params.parent->GetRootWindow();
-    ui::Window* parent_root_mus = parent_root_aura->GetProperty(kMusWindow);
-    if (parent_root_mus) {
-      parent_root_mus->AddTransientWindow(window_);
-      if (!parent_mus)
-        parent_mus = parent_root_mus;
-    }
-  }
-
-  if (parent_mus)
-    parent_mus->AddChild(window_);
-
-  // TODO(sky): deal with show state.
-  if (!params.bounds.size().IsEmpty())
-    SetBounds(params.bounds);
-
-  // TODO(beng): much else, see [Desktop]NativeWidgetAura.
-
-  native_widget_delegate_->OnNativeWidgetCreated(false);
-}
-
-void NativeWidgetMus::OnWidgetInitDone() {
-  // The client area is calculated from the NonClientView. During
-  // InitNativeWidget() the NonClientView has not been created. When this
-  // function is called the NonClientView has been created, so that we can
-  // correctly calculate the client area and push it to the ui::Window.
-  UpdateClientArea();
-  UpdateHitTestMask();
-}
-
-bool NativeWidgetMus::ShouldUseNativeFrame() const {
-  NOTIMPLEMENTED();
-  return false;
-}
-
-bool NativeWidgetMus::ShouldWindowContentsBeTransparent() const {
-  NOTIMPLEMENTED();
-  return true;
-}
-
-void NativeWidgetMus::FrameTypeChanged() {
-  NOTIMPLEMENTED();
-}
-
-Widget* NativeWidgetMus::GetWidget() {
-  return native_widget_delegate_->AsWidget();
-}
-
-const Widget* NativeWidgetMus::GetWidget() const {
-  return native_widget_delegate_->AsWidget();
-}
-
-gfx::NativeView NativeWidgetMus::GetNativeView() const {
-  return content_;
-}
-
-gfx::NativeWindow NativeWidgetMus::GetNativeWindow() const {
-  return content_;
-}
-
-Widget* NativeWidgetMus::GetTopLevelWidget() {
-  return GetWidget();
-}
-
-const ui::Compositor* NativeWidgetMus::GetCompositor() const {
-  return window_tree_host_->compositor();
-}
-
-const ui::Layer* NativeWidgetMus::GetLayer() const {
-  return content_ ? content_->layer() : nullptr;
-}
-
-void NativeWidgetMus::ReorderNativeViews() {
-  NOTIMPLEMENTED();
-}
-
-void NativeWidgetMus::ViewRemoved(View* view) {
-  NOTIMPLEMENTED();
-}
-
-// These methods are wrong in mojo. They're not usually used to associate data
-// with a window; they are used to pass data from one layer to another (and in
-// chrome/ to unsafely pass raw pointers around--I can only find two places
-// where we do the "safe" thing and even that requires casting an integer to a
-// void*). They can't be used safely in a world where we separate things with
-// mojo.
-//
-// It's also used to communicate between views and aura; in views, we set
-// properties on a widget, and read these properties directly in aura code.
-void NativeWidgetMus::SetNativeWindowProperty(const char* name, void* value) {
-  if (content_)
-    content_->SetNativeWindowProperty(name, value);
-}
-
-void* NativeWidgetMus::GetNativeWindowProperty(const char* name) const {
-  return content_ ? content_->GetNativeWindowProperty(name) : nullptr;
-}
-
-TooltipManager* NativeWidgetMus::GetTooltipManager() const {
-  return tooltip_manager_.get();
-}
-
-void NativeWidgetMus::SetCapture() {
-  if (content_)
-    content_->SetCapture();
-}
-
-void NativeWidgetMus::ReleaseCapture() {
-  if (content_)
-    content_->ReleaseCapture();
-}
-
-bool NativeWidgetMus::HasCapture() const {
-  return content_ && content_->HasCapture();
-}
-
-ui::InputMethod* NativeWidgetMus::GetInputMethod() {
-  return window_tree_host_ ? window_tree_host_->GetInputMethod() : nullptr;
-}
-
-void NativeWidgetMus::CenterWindow(const gfx::Size& size) {
-  if (is_parallel_widget_in_window_manager())
-    return;
-  // TODO(beng): clear user-placed property and set preferred size property.
-  window_->SetSharedProperty<gfx::Size>(
-      ui::mojom::WindowManager::kPreferredSize_Property, size);
-
-  gfx::Rect bounds = display::Screen::GetScreen()
-                         ->GetDisplayNearestWindow(content_)
-                         .work_area();
-  bounds.ClampToCenteredSize(size);
-  window_->SetBounds(bounds);
-}
-
-void NativeWidgetMus::GetWindowPlacement(
-      gfx::Rect* bounds,
-      ui::WindowShowState* maximized) const {
-  NOTIMPLEMENTED();
-}
-
-bool NativeWidgetMus::SetWindowTitle(const base::string16& title) {
-  if (!window_ || is_parallel_widget_in_window_manager())
-    return false;
-  const char* kWindowTitle_Property =
-      ui::mojom::WindowManager::kWindowTitle_Property;
-  const base::string16 current_title =
-      window_->HasSharedProperty(kWindowTitle_Property)
-          ? window_->GetSharedProperty<base::string16>(kWindowTitle_Property)
-          : base::string16();
-  if (current_title == title)
-    return false;
-  window_->SetSharedProperty<base::string16>(kWindowTitle_Property, title);
-  return true;
-}
-
-void NativeWidgetMus::SetWindowIcons(const gfx::ImageSkia& window_icon,
-                                     const gfx::ImageSkia& app_icon) {
-  if (is_parallel_widget_in_window_manager())
-    return;
-
-  SetIconProperty(window_, ui::mojom::WindowManager::kWindowIcon_Property,
-                  window_icon);
-  SetIconProperty(window_, ui::mojom::WindowManager::kAppIcon_Property,
-                  app_icon);
-}
-
-void NativeWidgetMus::InitModalType(ui::ModalType modal_type) {
-  if (modal_type != ui::MODAL_TYPE_NONE)
-    window_->SetModal();
-}
-
-gfx::Rect NativeWidgetMus::GetWindowBoundsInScreen() const {
-  if (!window_)
-    return gfx::Rect();
-
-  // Correct for the origin of the display.
-  const int64_t window_display_id = window_->GetRoot()->display_id();
-  for (display::Display display :
-       display::Screen::GetScreen()->GetAllDisplays()) {
-    if (display.id() == window_display_id) {
-      gfx::Point display_origin = display.bounds().origin();
-      gfx::Rect bounds_in_screen = window_->GetBoundsInRoot();
-      bounds_in_screen.Offset(display_origin.x(), display_origin.y());
-      return bounds_in_screen;
-    }
-  }
-  // Unknown display, assume primary display at 0,0.
-  return window_->GetBoundsInRoot();
-}
-
-gfx::Rect NativeWidgetMus::GetClientAreaBoundsInScreen() const {
-  // View-to-screen coordinate system transformations depend on this returning
-  // the full window bounds, for example View::ConvertPointToScreen().
-  return GetWindowBoundsInScreen();
-}
-
-gfx::Rect NativeWidgetMus::GetRestoredBounds() const {
-  // Restored bounds should only be relevant if the window is minimized,
-  // maximized, fullscreen or docked. However, in some places the code expects
-  // GetRestoredBounds() to return the current window bounds if the window is
-  // not in either state.
-  if (IsMinimized() || IsMaximized() || IsFullscreen()) {
-    const char* kRestoreBounds_Property =
-        ui::mojom::WindowManager::kRestoreBounds_Property;
-    if (window_->HasSharedProperty(kRestoreBounds_Property))
-      return window_->GetSharedProperty<gfx::Rect>(kRestoreBounds_Property);
-  }
-  return GetWindowBoundsInScreen();
-}
-
-std::string NativeWidgetMus::GetWorkspace() const {
-  return std::string();
-}
-
-void NativeWidgetMus::SetBounds(const gfx::Rect& bounds_in_screen) {
-  if (!(window_ && window_tree_host_))
-    return;
-
-  // TODO(jamescook): Needs something like aura::ScreenPositionClient so higher
-  // level code can move windows between displays. crbug.com/645291
-  gfx::Point origin(bounds_in_screen.origin());
-  const gfx::Point display_origin = display::Screen::GetScreen()
-                                        ->GetDisplayMatching(bounds_in_screen)
-                                        .bounds()
-                                        .origin();
-  origin.Offset(-display_origin.x(), -display_origin.y());
-
-  gfx::Size size(bounds_in_screen.size());
-  const gfx::Size min_size = GetMinimumSize();
-  const gfx::Size max_size = GetMaximumSize();
-  if (!max_size.IsEmpty())
-    size.SetToMin(max_size);
-  size.SetToMax(min_size);
-  window_->SetBounds(gfx::Rect(origin, size));
-  // Observer on |window_tree_host_| expected to synchronously update bounds.
-  DCHECK_EQ(gfx::ConvertRectToPixel(ScaleFactorForDisplay(content_),
-                                    window_->bounds())
-                .ToString(),
-            window_tree_host_->GetBoundsInPixels().ToString());
-}
-
-void NativeWidgetMus::SetSize(const gfx::Size& size) {
-  if (!window_tree_host_)
-    return;
-
-  gfx::Rect bounds = window_tree_host_->GetBoundsInPixels();
-  SetBounds(gfx::Rect(bounds.origin(), size));
-}
-
-void NativeWidgetMus::StackAbove(gfx::NativeView native_view) {
-  NOTIMPLEMENTED();
-}
-
-void NativeWidgetMus::StackAtTop() {
-  NOTIMPLEMENTED();
-}
-
-void NativeWidgetMus::SetShape(std::unique_ptr<SkRegion> shape) {
-  NOTIMPLEMENTED();
-}
-
-void NativeWidgetMus::Close() {
-  Hide();
-  if (!close_widget_factory_.HasWeakPtrs()) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&NativeWidgetMus::CloseNow,
-                              close_widget_factory_.GetWeakPtr()));
-  }
-}
-
-void NativeWidgetMus::CloseNow() {
-  // Depending upon ownership |window_| may have been destroyed.
-  if (window_)
-    window_->Destroy();
-}
-
-void NativeWidgetMus::Show() {
-  ShowWithWindowState(ui::SHOW_STATE_NORMAL);
-}
-
-void NativeWidgetMus::Hide() {
-  if (!(window_ && window_tree_host_))
-    return;
-
-  // NOTE: |window_tree_host_| and |window_| visibility is updated in
-  // OnMusWindowVisibilityChanged().
-  window_->SetVisible(false);
-}
-
-void NativeWidgetMus::ShowMaximizedWithBounds(
-    const gfx::Rect& restored_bounds) {
-  if (!window_)
-    return;
-
-  window_->SetSharedProperty<gfx::Rect>(
-      ui::mojom::WindowManager::kRestoreBounds_Property, restored_bounds);
-  ShowWithWindowState(ui::SHOW_STATE_MAXIMIZED);
-}
-
-void NativeWidgetMus::ShowWithWindowState(ui::WindowShowState state) {
-  if (!(window_ && window_tree_host_))
-    return;
-
-  // Matches NativeWidgetAura.
-  switch (state) {
-    case ui::SHOW_STATE_MAXIMIZED:
-      SetShowState(ui::mojom::ShowState::MAXIMIZED);
-      break;
-    case ui::SHOW_STATE_FULLSCREEN:
-      SetShowState(ui::mojom::ShowState::FULLSCREEN);
-      break;
-    case ui::SHOW_STATE_DOCKED:
-      SetShowState(ui::mojom::ShowState::DOCKED);
-      break;
-    default:
-      break;
-  }
-
-  // NOTE: |window_tree_host_| and |window_| visibility is updated in
-  // OnMusWindowVisibilityChanged().
-  window_->SetVisible(true);
-  if (native_widget_delegate_->CanActivate()) {
-    if (state != ui::SHOW_STATE_INACTIVE)
-      Activate();
-    GetWidget()->SetInitialFocus(state);
-  }
-
-  // Matches NativeWidgetAura.
-  if (state == ui::SHOW_STATE_MINIMIZED)
-    Minimize();
-}
-
-bool NativeWidgetMus::IsVisible() const {
-  // TODO(beng): this should probably be wired thru PlatformWindow.
-  return window_ && window_->visible();
-}
-
-void NativeWidgetMus::Activate() {
-  if (!window_)
-    return;
-
-  static_cast<aura::client::ActivationClient*>(focus_client_.get())
-      ->ActivateWindow(content_);
-}
-
-void NativeWidgetMus::Deactivate() {
-  if (IsActive())
-    window_->window_tree()->ClearFocus();
-}
-
-bool NativeWidgetMus::IsActive() const {
-  ui::Window* focused =
-      window_ ? window_->window_tree()->GetFocusedWindow() : nullptr;
-  return focused && window_->Contains(focused);
-}
-
-void NativeWidgetMus::SetAlwaysOnTop(bool always_on_top) {
-  if (window_ && !is_parallel_widget_in_window_manager()) {
-    window_->SetSharedProperty<bool>(
-        ui::mojom::WindowManager::kAlwaysOnTop_Property, always_on_top);
-  }
-}
-
-bool NativeWidgetMus::IsAlwaysOnTop() const {
-  return window_ &&
-         window_->HasSharedProperty(
-             ui::mojom::WindowManager::kAlwaysOnTop_Property) &&
-         window_->GetSharedProperty<bool>(
-             ui::mojom::WindowManager::kAlwaysOnTop_Property);
-}
-
-void NativeWidgetMus::SetVisibleOnAllWorkspaces(bool always_visible) {
-  // Not needed for chromeos.
-}
-
-bool NativeWidgetMus::IsVisibleOnAllWorkspaces() const {
-  return false;
-}
-
-void NativeWidgetMus::Maximize() {
-  SetShowState(ui::mojom::ShowState::MAXIMIZED);
-}
-
-void NativeWidgetMus::Minimize() {
-  SetShowState(ui::mojom::ShowState::MINIMIZED);
-}
-
-bool NativeWidgetMus::IsMaximized() const {
-  return GetShowState(window_) == ui::mojom::ShowState::MAXIMIZED;
-}
-
-bool NativeWidgetMus::IsMinimized() const {
-  return GetShowState(window_) == ui::mojom::ShowState::MINIMIZED;
-}
-
-void NativeWidgetMus::Restore() {
-  SetShowState(ui::mojom::ShowState::NORMAL);
-}
-
-void NativeWidgetMus::SetFullscreen(bool fullscreen) {
-  if (IsFullscreen() == fullscreen)
-    return;
-  if (fullscreen) {
-    show_state_before_fullscreen_ = GetShowState(window_);
-    SetShowState(ui::mojom::ShowState::FULLSCREEN);
-  } else {
-    switch (show_state_before_fullscreen_) {
-      case ui::mojom::ShowState::MAXIMIZED:
-        Maximize();
-        break;
-      case ui::mojom::ShowState::MINIMIZED:
-        Minimize();
-        break;
-      case ui::mojom::ShowState::DEFAULT:
-      case ui::mojom::ShowState::NORMAL:
-      case ui::mojom::ShowState::INACTIVE:
-      case ui::mojom::ShowState::FULLSCREEN:
-      case ui::mojom::ShowState::DOCKED:
-        // TODO(sad): This may not be sufficient.
-        Restore();
-        break;
-    }
-  }
-}
-
-bool NativeWidgetMus::IsFullscreen() const {
-  return GetShowState(window_) == ui::mojom::ShowState::FULLSCREEN;
-}
-
-void NativeWidgetMus::SetOpacity(float opacity) {
-  if (window_)
-    window_->SetOpacity(opacity);
-}
-
-void NativeWidgetMus::FlashFrame(bool flash_frame) {
-  NOTIMPLEMENTED();
-}
-
-void NativeWidgetMus::RunShellDrag(View* view,
-                                   const ui::OSExchangeData& data,
-                                   const gfx::Point& location,
-                                   int drag_operations,
-                                   ui::DragDropTypes::DragEventSource source) {
-  if (window_)
-    views::RunShellDrag(content_, data, location, drag_operations, source);
-}
-
-void NativeWidgetMus::SchedulePaintInRect(const gfx::Rect& rect) {
-  if (content_)
-    content_->SchedulePaintInRect(rect);
-}
-
-void NativeWidgetMus::SetCursor(gfx::NativeCursor cursor) {
-  if (!window_)
-    return;
-
-  // TODO(erg): In aura, our incoming cursor is really two
-  // parts. cursor.native_type() is an integer for standard cursors and is all
-  // we support right now. If native_type() == kCursorCustom, than we should
-  // also send an image, but as the cursor code is currently written, the image
-  // is in a platform native format that's already uploaded to the window
-  // server.
-  ui::mojom::Cursor new_cursor = ui::mojom::Cursor(cursor.native_type());
-  if (last_cursor_ != new_cursor)
-    window_->SetPredefinedCursor(new_cursor);
-}
-
-bool NativeWidgetMus::IsMouseEventsEnabled() const {
-  NOTIMPLEMENTED();
-  return true;
-}
-
-void NativeWidgetMus::ClearNativeFocus() {
-  if (!IsActive())
-    return;
-  ui::Window* focused =
-      window_ ? window_->window_tree()->GetFocusedWindow() : nullptr;
-  if (focused && window_->Contains(focused) && focused != window_)
-    window_->SetFocus();
-  // Move aura-focus back to |content_|, so that the Widget still receives
-  // events correctly.
-  aura::client::GetFocusClient(content_)->ResetFocusWithinActiveWindow(
-      content_);
-}
-
-gfx::Rect NativeWidgetMus::GetWorkAreaBoundsInScreen() const {
-  NOTIMPLEMENTED();
-  return gfx::Rect();
-}
-
-Widget::MoveLoopResult NativeWidgetMus::RunMoveLoop(
-    const gfx::Vector2d& drag_offset,
-    Widget::MoveLoopSource source,
-    Widget::MoveLoopEscapeBehavior escape_behavior) {
-  ReleaseCapture();
-
-  base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
-  base::MessageLoop::ScopedNestableTaskAllower allow_nested(loop);
-  base::RunLoop run_loop;
-
-  ui::mojom::MoveLoopSource mus_source =
-      source == Widget::MOVE_LOOP_SOURCE_MOUSE
-          ? ui::mojom::MoveLoopSource::MOUSE
-          : ui::mojom::MoveLoopSource::TOUCH;
-
-  bool success = false;
-  gfx::Point cursor_location =
-      display::Screen::GetScreen()->GetCursorScreenPoint();
-  window_->PerformWindowMove(
-      mus_source, cursor_location,
-      base::Bind(OnMoveLoopEnd, &success, run_loop.QuitClosure()));
-
-  run_loop.Run();
-
-  return success ? Widget::MOVE_LOOP_SUCCESSFUL : Widget::MOVE_LOOP_CANCELED;
-}
-
-void NativeWidgetMus::EndMoveLoop() {
-  window_->CancelWindowMove();
-}
-
-void NativeWidgetMus::SetVisibilityChangedAnimationsEnabled(bool value) {
-  NOTIMPLEMENTED();
-}
-
-void NativeWidgetMus::SetVisibilityAnimationDuration(
-    const base::TimeDelta& duration) {
-  NOTIMPLEMENTED();
-}
-
-void NativeWidgetMus::SetVisibilityAnimationTransition(
-    Widget::VisibilityTransition transition) {
-  NOTIMPLEMENTED();
-}
-
-bool NativeWidgetMus::IsTranslucentWindowOpacitySupported() const {
-  NOTIMPLEMENTED();
-  return true;
-}
-
-void NativeWidgetMus::OnSizeConstraintsChanged() {
-  if (!window_ || is_parallel_widget_in_window_manager())
-    return;
-
-  int32_t behavior = ui::mojom::kResizeBehaviorNone;
-  if (GetWidget()->widget_delegate())
-    behavior = GetWidget()->widget_delegate()->GetResizeBehavior();
-  window_->SetSharedProperty<PrimitiveType>(
-      ui::mojom::WindowManager::kResizeBehavior_Property, behavior);
-}
-
-void NativeWidgetMus::RepostNativeEvent(gfx::NativeEvent native_event) {
-  NOTIMPLEMENTED();
-}
-
-std::string NativeWidgetMus::GetName() const {
-  return window_->GetName();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetMus, aura::WindowDelegate implementation:
-
-gfx::Size NativeWidgetMus::GetMinimumSize() const {
-  return native_widget_delegate_->GetMinimumSize();
-}
-
-gfx::Size NativeWidgetMus::GetMaximumSize() const {
-  return native_widget_delegate_->GetMaximumSize();
-}
-
-void NativeWidgetMus::OnBoundsChanged(const gfx::Rect& old_bounds,
-                                      const gfx::Rect& new_bounds) {
-  // This is handled in OnHost{Resized,Moved}() like DesktopNativeWidgetAura
-  // instead of here like in NativeWidgetAura.
-}
-
-gfx::NativeCursor NativeWidgetMus::GetCursor(const gfx::Point& point) {
-  return gfx::NativeCursor();
-}
-
-int NativeWidgetMus::GetNonClientComponent(const gfx::Point& point) const {
-  return native_widget_delegate_->GetNonClientComponent(point);
-}
-
-bool NativeWidgetMus::ShouldDescendIntoChildForEventHandling(
-    aura::Window* child,
-    const gfx::Point& location) {
-  views::WidgetDelegate* widget_delegate = GetWidget()->widget_delegate();
-  return !widget_delegate ||
-      widget_delegate->ShouldDescendIntoChildForEventHandling(child, location);
-}
-
-bool NativeWidgetMus::CanFocus() {
-  return true;
-}
-
-void NativeWidgetMus::OnCaptureLost() {
-  native_widget_delegate_->OnMouseCaptureLost();
-}
-
-void NativeWidgetMus::OnPaint(const ui::PaintContext& context) {
-  native_widget_delegate_->OnNativeWidgetPaint(context);
-}
-
-void NativeWidgetMus::OnDeviceScaleFactorChanged(float device_scale_factor) {
-}
-
-void NativeWidgetMus::OnWindowDestroying(aura::Window* window) {
-}
-
-void NativeWidgetMus::OnWindowDestroyed(aura::Window* window) {
-  // Cleanup happens in OnPlatformWindowClosed().
-}
-
-void NativeWidgetMus::OnWindowTargetVisibilityChanged(bool visible) {
-}
-
-bool NativeWidgetMus::HasHitTestMask() const {
-  return native_widget_delegate_->HasHitTestMask();
-}
-
-void NativeWidgetMus::GetHitTestMask(gfx::Path* mask) const {
-  native_widget_delegate_->GetHitTestMask(mask);
-}
-
-void NativeWidgetMus::SetShowState(ui::mojom::ShowState show_state) {
-  if (!window_)
-    return;
-  window_->SetSharedProperty<PrimitiveType>(
-      ui::mojom::WindowManager::kShowState_Property,
-      static_cast<PrimitiveType>(show_state));
-}
-
-void NativeWidgetMus::OnKeyEvent(ui::KeyEvent* event) {
-  if (event->is_char()) {
-    // If a ui::InputMethod object is attached to the root window, character
-    // events are handled inside the object and are not passed to this function.
-    // If such object is not attached, character events might be sent (e.g. on
-    // Windows). In this case, we just skip these.
-    return;
-  }
-  // Renderer may send a key event back to us if the key event wasn't handled,
-  // and the window may be invisible by that time.
-  if (!content_->IsVisible())
-    return;
-
-  native_widget_delegate_->OnKeyEvent(event);
-}
-
-void NativeWidgetMus::OnMouseEvent(ui::MouseEvent* event) {
-  DCHECK(content_->IsVisible());
-
-  if (tooltip_manager_.get())
-    tooltip_manager_->UpdateTooltip();
-  TooltipManagerAura::UpdateTooltipManagerForCapture(GetWidget());
-
-  native_widget_delegate_->OnMouseEvent(event);
-  // WARNING: we may have been deleted.
-}
-
-void NativeWidgetMus::OnScrollEvent(ui::ScrollEvent* event) {
-  if (event->type() == ui::ET_SCROLL) {
-    native_widget_delegate_->OnScrollEvent(event);
-    if (event->handled())
-      return;
-
-    // Convert unprocessed scroll events into wheel events.
-    ui::MouseWheelEvent mwe(*event->AsScrollEvent());
-    native_widget_delegate_->OnMouseEvent(&mwe);
-    if (mwe.handled())
-      event->SetHandled();
-  } else {
-    native_widget_delegate_->OnScrollEvent(event);
-  }
-}
-
-void NativeWidgetMus::OnGestureEvent(ui::GestureEvent* event) {
-  native_widget_delegate_->OnGestureEvent(event);
-}
-
-void NativeWidgetMus::OnHostResized(const aura::WindowTreeHost* host) {
-  native_widget_delegate_->OnNativeWidgetSizeChanged(
-      host->window()->bounds().size());
-  UpdateClientArea();
-  UpdateHitTestMask();
-}
-
-void NativeWidgetMus::OnHostMovedInPixels(
-    const aura::WindowTreeHost* host,
-    const gfx::Point& new_origin_in_pixels) {
-  native_widget_delegate_->OnNativeWidgetMove();
-}
-
-void NativeWidgetMus::OnHostCloseRequested(const aura::WindowTreeHost* host) {
-  GetWidget()->Close();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetMus, aura::WindowDragDropDelegate implementation:
-
-void NativeWidgetMus::OnDragEntered(const ui::DropTargetEvent& event) {
-  DCHECK(drop_helper_);
-  last_drop_operation_ = drop_helper_->OnDragOver(
-      event.data(), event.location(), event.source_operations());
-}
-
-int NativeWidgetMus::OnDragUpdated(const ui::DropTargetEvent& event) {
-  DCHECK(drop_helper_);
-  last_drop_operation_ = drop_helper_->OnDragOver(
-      event.data(), event.location(), event.source_operations());
-  return last_drop_operation_;
-}
-
-void NativeWidgetMus::OnDragExited() {
-  DCHECK(drop_helper_);
-  drop_helper_->OnDragExit();
-}
-
-int NativeWidgetMus::OnPerformDrop(const ui::DropTargetEvent& event) {
-  DCHECK(drop_helper_);
-  return drop_helper_->OnDrop(event.data(), event.location(),
-                              last_drop_operation_);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetMus, ui::InputEventHandler implementation:
-
-void NativeWidgetMus::OnWindowInputEvent(
-    ui::Window* view,
-    const ui::Event& event_in,
-    std::unique_ptr<base::Callback<void(EventResult)>>* ack_callback) {
-  std::unique_ptr<ui::Event> event = ui::Event::Clone(event_in);
-
-  if (event->IsKeyEvent()) {
-    input_method_->DispatchKeyEvent(event->AsKeyEvent(),
-                                    std::move(*ack_callback));
-    return;
-  }
-
-  // Take ownership of the callback, indicating that we will handle it.
-  EventAckHandler ack_handler(std::move(*ack_callback));
-
-  // TODO(markdittmer): This should be this->OnEvent(event.get()), but that
-  // can't happen until IME is refactored out of in WindowTreeHostMus.
-  platform_window_delegate()->DispatchEvent(event.get());
-  // NOTE: |this| may be deleted.
-
-  ack_handler.set_handled(event->handled());
-  // |ack_handler| acks the event on destruction if necessary.
-}
-
-void NativeWidgetMus::OnMusWindowVisibilityChanging(ui::Window* window,
-                                                    bool visible) {
-  if (window == window_)
-    native_widget_delegate_->OnNativeWidgetVisibilityChanging(visible);
-}
-
-void NativeWidgetMus::OnMusWindowVisibilityChanged(ui::Window* window,
-                                                   bool visible) {
-  if (window != window_)
-    return;
-
-  if (visible) {
-    window_tree_host_->Show();
-    GetNativeWindow()->Show();
-  } else {
-    window_tree_host_->Hide();
-    GetNativeWindow()->Hide();
-  }
-  native_widget_delegate_->OnNativeWidgetVisibilityChanged(visible);
-}
-
-void NativeWidgetMus::UpdateHitTestMask() {
-  // The window manager (or other underlay window provider) is not allowed to
-  // set a hit test mask, as that could interfere with a client app mask.
-  if (is_parallel_widget_in_window_manager())
-    return;
-
-  if (!native_widget_delegate_->HasHitTestMask()) {
-    window_->ClearHitTestMask();
-    return;
-  }
-
-  gfx::Path mask_path;
-  native_widget_delegate_->GetHitTestMask(&mask_path);
-  // TODO(jamescook): Use the full path for the mask.
-  gfx::Rect mask_rect =
-      gfx::ToEnclosingRect(gfx::SkRectToRectF(mask_path.getBounds()));
-  window_->SetHitTestMask(mask_rect);
-}
-
-}  // namespace views