Re-reland Propagate OnNativeWidgetMove to delegate/observers, etc.

chrome/browser/ui/views/tabs/tab_drag_controller2.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 "chrome/browser/ui/views/tabs/tab_drag_controller2.h"
 
 #include <math.h>
 #include <set>
 
 #include "base/callback.h"
@@ skipping 20 matching lines @@
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/animation/animation.h"
 #include "ui/base/animation/animation_delegate.h"
 #include "ui/base/animation/slide_animation.h"
 #include "ui/base/events.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/events/event.h"
 #include "ui/views/widget/root_view.h"
-#include "ui/views/widget/widget.h"
 
 #if defined(USE_ASH)
 #include "ash/wm/property_util.h"
 #endif
 
 using content::UserMetricsAction;
 using content::WebContents;
 
 static const int kHorizontalMoveThreshold = 16;  // Pixels.
 
@@ skipping 255 matching lines @@
       offset_to_width_ratio_(0),
       old_focused_view_(NULL),
       last_move_screen_loc_(0),
       started_drag_(false),
       active_(true),
       source_tab_index_(std::numeric_limits<size_t>::max()),
       initial_move_(true),
       end_run_loop_behavior_(END_RUN_LOOP_STOP_DRAGGING),
       waiting_for_run_loop_to_exit_(false),
       tab_strip_to_attach_to_after_exit_(NULL),
-      move_loop_browser_view_(NULL),
+      move_loop_widget_(NULL),
       destroyed_(NULL) {
   instance_ = this;
 }
 
 TabDragController2::~TabDragController2() {
   if (instance_ == this)
     instance_ = NULL;
 
   if (destroyed_)
     *destroyed_ = true;
 
-  if (move_loop_browser_view_) {
-    move_loop_browser_view_->set_move_observer(NULL);
-    SetTrackedByWorkspace(
-        move_loop_browser_view_->GetWidget()->GetNativeView(), true);
+  if (move_loop_widget_) {
+    move_loop_widget_->RemoveObserver(this);
+    SetTrackedByWorkspace(move_loop_widget_->GetNativeView(), true);
   }
 
   if (source_tabstrip_)
     GetModel(source_tabstrip_)->RemoveObserver(this);
 
   MessageLoopForUI::current()->RemoveObserver(this);
 }
 
 void TabDragController2::Init(
     TabStrip* source_tabstrip,
@@ skipping 117 matching lines @@
   // to the way they were. This is the most reliable way to do this since no
   // single view or window reliably receives events throughout all the various
   // kinds of tab dragging.
   if (ui::EventTypeFromNative(event) == ui::ET_KEY_PRESSED &&
       ui::KeyboardCodeFromNative(event) == ui::VKEY_ESCAPE) {
     EndDrag(true);
   }
 }
 #endif
 
-void TabDragController2::OnWidgetMoved() {
+void TabDragController2::OnWidgetMoved(views::Widget* widget) {
   Drag();
 }
 
 void TabDragController2::TabStripEmpty() {
   GetModel(source_tabstrip_)->RemoveObserver(this);
   // NULL out source_tabstrip_ so that we don't attempt to add back to in (in
   // the case of a revert).
   source_tabstrip_ = NULL;
 }
 
@@ skipping 115 matching lines @@
   if (tab_strip_changed) {
     if (!target_tabstrip) {
       DetachIntoNewBrowserAndRunMoveLoop(screen_point);
       return;
     }
     if (is_dragging_window_) {
 #if defined(USE_ASH)
       // ReleaseMouseCapture() is going to result in calling back to us (because
       // it results in a move). That'll cause all sorts of problems.  Reset the
       // observer so we don't get notified and process the event.
-      move_loop_browser_view_->set_move_observer(NULL);
-      move_loop_browser_view_ = NULL;
+      move_loop_widget_->RemoveObserver(this);
+      move_loop_widget_ = NULL;
 #endif
-      BrowserView* browser_view = GetAttachedBrowserView();
+      views::Widget* browser_widget = GetAttachedBrowserWidget();
       // Need to release the drag controller before starting the move loop as
       // it's going to trigger capture lost, which cancels drag.
       attached_tabstrip_->ReleaseDragController();
       target_tabstrip->OwnDragController(this);
       // Disable animations so that we don't see a close animation on aero.
-      browser_view->GetWidget()->SetVisibilityChangedAnimationsEnabled(false);
-      browser_view->GetWidget()->ReleaseMouseCapture();
+      browser_widget->SetVisibilityChangedAnimationsEnabled(false);
+      browser_widget->ReleaseMouseCapture();
       // EndMoveLoop is going to snap the window back to its original location.
       // Hide it so users don't see this.
-      browser_view->GetWidget()->Hide();
-      browser_view->GetWidget()->EndMoveLoop();
+      browser_widget->Hide();
+      browser_widget->EndMoveLoop();
 
       // Ideally we would always swap the tabs now, but on windows it seems that
       // running the move loop implicitly activates the window when done,
       // leading to all sorts of flicker. So, on windows, instead we process
       // the move after the loop completes. But on chromeos, we can do tab
       // swapping now to avoid the tab flashing issue(crbug.com/116329).
 #if defined(USE_ASH)
       is_dragging_window_ = false;
       Detach();
       gfx::Point screen_point(GetCursorScreenPoint());
@@ skipping 344 matching lines @@
       drag_bounds);
 
   browser->window()->Show();
   browser->window()->Activate();
   dragged_browser_view->GetWidget()->SetVisibilityChangedAnimationsEnabled(
       true);
   RunMoveLoop();
 }
 
 void TabDragController2::RunMoveLoop() {
-  move_loop_browser_view_ = GetAttachedBrowserView();
-  DCHECK(move_loop_browser_view_);
-  move_loop_browser_view_->set_move_observer(this);
+  move_loop_widget_ = GetAttachedBrowserWidget();
+  move_loop_widget_->AddObserver(this);
   is_dragging_window_ = true;
   bool destroyed = false;
   destroyed_ = &destroyed;
   // Running the move loop release mouse capture on windows, which triggers
   // destroying the drag loop. Release mouse capture ourself before this while
   // the Dragcontroller isn't owned by the TabStrip.
   attached_tabstrip_->ReleaseDragController();
   attached_tabstrip_->GetWidget()->ReleaseMouseCapture();
   attached_tabstrip_->OwnDragController(this);
-  views::Widget::MoveLoopResult result =
-      move_loop_browser_view_->GetWidget()->RunMoveLoop();
+  views::Widget::MoveLoopResult result = move_loop_widget_->RunMoveLoop();
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_DRAG_LOOP_DONE,
       content::NotificationService::AllBrowserContextsAndSources(),
       content::NotificationService::NoDetails());
 
   if (destroyed)
     return;
   destroyed_ = NULL;
-  // Under chromeos we immediately set the |move_loop_browser_view_| to NULL.
-  if (move_loop_browser_view_) {
-    move_loop_browser_view_->set_move_observer(NULL);
-    move_loop_browser_view_ = NULL;
+  // Under chromeos we immediately set the |move_loop_widget_| to NULL.
+  if (move_loop_widget_) {
+    move_loop_widget_->RemoveObserver(this);
+    move_loop_widget_ = NULL;
   }
   is_dragging_window_ = false;
   waiting_for_run_loop_to_exit_ = false;
   if (end_run_loop_behavior_ == END_RUN_LOOP_CONTINUE_DRAGGING) {
     end_run_loop_behavior_ = END_RUN_LOOP_STOP_DRAGGING;
     if (tab_strip_to_attach_to_after_exit_) {
       Detach();
       gfx::Point screen_point(GetCursorScreenPoint());
       Attach(tab_strip_to_attach_to_after_exit_, screen_point);
       // Move the tabs into position.
@@ skipping 101 matching lines @@
   return tabs;
 }
 
 void TabDragController2::EndDragImpl(EndDragType type) {
   DCHECK(active_);
   active_ = false;
 
   bring_to_front_timer_.Stop();
 
   if (is_dragging_window_) {
-    if (type == NORMAL || (type == TAB_DESTROYED && drag_data_.size() > 1)) {
-      SetTrackedByWorkspace(
-          GetAttachedBrowserView()->GetWidget()->GetNativeView(), true);
-    }
+    if (type == NORMAL || (type == TAB_DESTROYED && drag_data_.size() > 1))
+      SetTrackedByWorkspace(GetAttachedBrowserWidget()->GetNativeView(), true);
 
     // End the nested drag loop.
-    GetAttachedBrowserView()->GetWidget()->EndMoveLoop();
+    GetAttachedBrowserWidget()->EndMoveLoop();
     waiting_for_run_loop_to_exit_ = true;
   }
 
   // Hide the current dock controllers.
   for (size_t i = 0; i < dock_controllers_.size(); ++i) {
     // Be sure and clear the controller first, that way if Hide ends up
     // deleting the controller it won't call us back.
     dock_controllers_[i]->clear_controller();
     dock_controllers_[i]->Hide();
   }
@@ skipping 228 matching lines @@
     }
   }
 }
 
 // static
 TabStripModel* TabDragController2::GetModel(TabStrip* tabstrip) {
   return static_cast<BrowserTabStripController*>(tabstrip->controller())->
       model();
 }
 
-BrowserView* TabDragController2::GetAttachedBrowserView() {
+views::Widget* TabDragController2::GetAttachedBrowserWidget() {
   return BrowserView::GetBrowserViewForNativeWindow(
-      attached_tabstrip_->GetWidget()->GetNativeView());
+      attached_tabstrip_->GetWidget()->GetNativeView())->GetWidget();
 }
 
 bool TabDragController2::AreTabsConsecutive() {
   for (size_t i = 1; i < drag_data_.size(); ++i) {
     if (drag_data_[i - 1].source_model_index + 1 !=
         drag_data_[i].source_model_index) {
       return false;
     }
   }
   return true;
@@ skipping 33 matching lines @@
   browser->window()->SetBounds(new_bounds);
   return browser;
 }
 
 void TabDragController2::SetTrackedByWorkspace(gfx::NativeWindow window,
                                                bool value) {
 #if defined(USE_ASH)
   ash::SetTrackedByWorkspace(window, value);
 #endif
 }