mus: Use TooltipManagerAura in NativeWidgetMus.

ui/views/mus/native_widget_mus.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.
 
 // 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/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"
@@ skipping 11 matching lines @@
 #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/path.h"
 #include "ui/native_theme/native_theme_aura.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/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*);
@@ skipping 525 matching lines @@
   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_tree_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);
 
@@ skipping 110 matching lines @@
   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_tree_client_ =
@@ skipping 85 matching lines @@
 }
 
 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 exclusively 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. They should be
-// removed; not ported.
+// 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) {
-  native_window_properties_[name] = value;
+  if (content_)
+    content_->SetNativeWindowProperty(name, value);
 }
 
 void* NativeWidgetMus::GetNativeWindowProperty(const char* name) const {
-  auto it = native_window_properties_.find(name);
-  if (it == native_window_properties_.end())
-    return nullptr;
-  return it->second;
+  return content_ ? content_->GetNativeWindowProperty(name) : nullptr;
 }
 
 TooltipManager* NativeWidgetMus::GetTooltipManager() const {
-  // NOTIMPLEMENTED();
-  return nullptr;
+  return tooltip_manager_.get();
 }
 
 void NativeWidgetMus::SetCapture() {
   if (content_)
     content_->SetCapture();
 }
 
 void NativeWidgetMus::ReleaseCapture() {
   if (content_)
     content_->ReleaseCapture();
@@ skipping 545 matching lines @@
   }
   // 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) {
-  // TODO(sky): forward to tooltipmanager. See NativeWidgetDesktopAura.
   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;
 
@@ skipping 108 matching lines @@
 
   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