mash: Migrate ScopedTargetRootWindow to //ash/common

ash/shelf/shelf_view.cc

 // Copyright (c) 2012 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 "ash/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/ash_constants.h"
 #include "ash/common/ash_switches.h"
+#include "ash/common/scoped_root_window_for_new_windows.h"
 #include "ash/common/shelf/app_list_button.h"
 #include "ash/common/shelf/overflow_bubble.h"
 #include "ash/common/shelf/overflow_bubble_view.h"
 #include "ash/common/shelf/overflow_button.h"
 #include "ash/common/shelf/shelf_button.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_menu_model.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/wm/root_window_finder.h"
+#include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
 #include "ash/drag_drop/drag_image_view.h"
-#include "ash/scoped_target_root_window.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_icon_observer.h"
 #include "ash/shelf/shelf_widget.h"
 #include "base/auto_reset.h"
 #include "base/metrics/histogram.h"
 #include "grit/ash_strings.h"
 #include "ui/accessibility/ax_view_state.h"
-#include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
-#include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/views/animation/bounds_animator.h"
@@ skipping 1646 matching lines @@
 
   // None of the checks in ShouldEventActivateButton() affects overflow button.
   // So, it is safe to be checked after handling overflow button.
   if (!ShouldEventActivateButton(sender, event))
     return;
 
   // Record the index for the last pressed shelf item.
   last_pressed_index_ = view_model_->GetIndexOfView(sender);
   DCHECK_LT(-1, last_pressed_index_);
 
-  scoped_target_root_window_.reset(new ScopedTargetRootWindow(
-      sender->GetWidget()->GetNativeView()->GetRootWindow()));
+  // Place new windows on the same display as the button.
+  WmWindow* root_window =

[msw, 2016/08/02 01:04:50]

optional nit: use a GetRootWindow pattern consistent with the one below:
  WmWindow* window = WmLookup::Get()->GetWindowForWidget(sender->GetWidget());
  scoped_root_window_for_new_windows_.reset(
      new ScopedRootWindowForNewWindows(window->GetRootWindow()));

[James Cook, 2016/08/02 16:16:04]

Done.

+      WmLookup::Get()->GetWindowForWidget(sender->GetWidget())->GetRootWindow();
+  scoped_root_window_for_new_windows_.reset(
+      new ScopedRootWindowForNewWindows(root_window));
   // Slow down activation animations if shift key is pressed.
   std::unique_ptr<ui::ScopedAnimationDurationScaleMode> slowing_animations;
   if (event.IsShiftDown()) {
     slowing_animations.reset(new ui::ScopedAnimationDurationScaleMode(
         ui::ScopedAnimationDurationScaleMode::SLOW_DURATION));
   }
 
   // Collect usage statistics before we decide what to do with the click.
   switch (model_->items()[last_pressed_index_].type) {
     case TYPE_APP_SHORTCUT:
@@ skipping 26 matching lines @@
                                                      performed_action);
 
   // For the app list menu no TRIGGERED ink drop effect is needed and it
   // handles its own ACTIVATED/DEACTIVATED states.
   if (performed_action == ShelfItemDelegate::kNewWindowCreated ||
       (performed_action != ShelfItemDelegate::kAppListMenuShown &&
        !ShowListMenuForView(model_->items()[last_pressed_index_], sender, event,
                             ink_drop))) {
     ink_drop->AnimateToState(views::InkDropState::ACTION_TRIGGERED);
   }
-  // Allow the menu to clear |scoped_target_root_window_| during OnMenuClosed.
+  // Allow the menu to clear |scoped_root_window_for_new_windows_| during
+  // OnMenuClosed.
   if (!IsShowingMenu())
-    scoped_target_root_window_.reset();
+    scoped_root_window_for_new_windows_.reset();
 }
 
 bool ShelfView::ShowListMenuForView(const ShelfItem& item,
                                     views::View* source,
                                     const ui::Event& event,
                                     views::InkDrop* ink_drop) {
   ShelfItemDelegate* item_delegate = model_->GetShelfItemDelegate(item.id);
   std::unique_ptr<ui::MenuModel> list_menu_model(
       item_delegate->CreateApplicationMenu(event.flags()));
 
@@ skipping 41 matching lines @@
       menu_model_.get(),
       base::Bind(&ShelfView::OnMenuClosed, base::Unretained(this), ink_drop)));
 
   closing_event_time_ = base::TimeTicks();
   int run_types = views::MenuRunner::ASYNC;
   if (context_menu)
     run_types |= views::MenuRunner::CONTEXT_MENU;
   launcher_menu_runner_.reset(
       new views::MenuRunner(menu_model_adapter_->CreateMenu(), run_types));
 
-  aura::Window* window = source->GetWidget()->GetNativeWindow();
-  scoped_target_root_window_.reset(
-      new ScopedTargetRootWindow(window->GetRootWindow()));
+  // Place new windows on the same display as the button that spawned the menu.
+  WmWindow* window = WmLookup::Get()->GetWindowForWidget(source->GetWidget());
+  scoped_root_window_for_new_windows_.reset(
+      new ScopedRootWindowForNewWindows(window->GetRootWindow()));
 
   views::MenuAnchorPosition menu_alignment = views::MENU_ANCHOR_TOPLEFT;
   gfx::Rect anchor = gfx::Rect(click_point, gfx::Size());
 
   if (!context_menu) {
     // Application lists use a bubble.
     // It is possible to invoke the menu while it is sliding into view. To cover
     // that case, the screen coordinates are offsetted by the animation delta.
-    anchor = source->GetBoundsInScreen() +
-             (window->GetTargetBounds().origin() - window->bounds().origin());
+    anchor = source->GetBoundsInScreen() + (window->GetTargetBounds().origin() -
+                                            window->GetBounds().origin());
 
     // Adjust the anchor location for shelf items with asymmetrical borders.
     if (source->border())
       anchor.Inset(source->border()->GetInsets());
 
     // Determine the menu alignment dependent on the shelf.
     menu_alignment = shelf_->SelectValueForShelfAlignment(
         views::MENU_ANCHOR_BUBBLE_ABOVE, views::MENU_ANCHOR_BUBBLE_RIGHT,
         views::MENU_ANCHOR_BUBBLE_LEFT);
   }
@@ skipping 13 matching lines @@
     owner_overflow_bubble_->HideBubbleAndRefreshButton();
 
   closing_event_time_ = launcher_menu_runner_->closing_event_time();
 
   if (ink_drop)
     ink_drop->AnimateToState(views::InkDropState::DEACTIVATED);
 
   launcher_menu_runner_.reset();
   menu_model_adapter_.reset();
   menu_model_.reset();
-  scoped_target_root_window_.reset();
+  scoped_root_window_for_new_windows_.reset();
 
   // Auto-hide or alignment might have changed, but only for this shelf.
   wm_shelf_->UpdateVisibilityState();
 }
 
 void ShelfView::OnBoundsAnimatorProgressed(views::BoundsAnimator* animator) {
   FOR_EACH_OBSERVER(ShelfIconObserver, observers_,
                     OnShelfIconPositionsChanged());
   PreferredSizeChanged();
 }
@@ skipping 35 matching lines @@
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
   const gfx::Rect bounds = GetBoundsInScreen();
   int distance = shelf_->SelectValueForShelfAlignment(
       bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
       bounds.x() - coordinate.x());
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash