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 268 matching lines @@
 }
 
 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);
+    views::Widget* browser_widget = move_loop_browser_view_->GetWidget();
+    browser_widget->RemoveObserver(this);
+    SetTrackedByWorkspace(browser_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::OnWidgetMove(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_->GetWidget()->RemoveObserver(this);

[Ben Goodger (Google), 2012/04/18 15:56:48]

Now that the only usage of |move_loop_browser_view_| is to obtain its widget,
can we just replace it with a Widget*? e.g.

views::Widget* move_loop_widget_;

[msw, 2012/04/18 20:02:48]

Done.

       move_loop_browser_view_ = NULL;
 #endif
       BrowserView* browser_view = GetAttachedBrowserView();
       // 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();
@@ skipping 360 matching lines @@
   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_browser_view_->GetWidget()->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();
   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_->GetWidget()->RemoveObserver(this);
     move_loop_browser_view_ = 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);
@@ skipping 413 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
 }