Add WorkspaceObserver to observe changes in workspace state

ui/aura_shell/workspace/workspace_manager.cc

 // Copyright (c) 2011 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 "ui/aura_shell/workspace/workspace_manager.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/screen_aura.h"
 #include "ui/aura/window.h"
 #include "ui/aura_shell/workspace/workspace.h"
+#include "ui/aura_shell/workspace/workspace_observer.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 
 namespace {
 
 // The horizontal margein between workspaces in pixels.
 const int kWorkspaceHorizontalMargin = 50;
 
@@ skipping 113 matching lines @@
   DCHECK(source);
   DCHECK(target);
   int source_ws_index = GetWorkspaceIndexContaining(source);
   int target_ws_index = GetWorkspaceIndexContaining(target);
   DCHECK(source_ws_index >= 0);
   DCHECK(target_ws_index >= 0);
   if (source_ws_index == target_ws_index) {
     workspaces_[source_ws_index]->RotateWindows(source, target);
   } else {
     aura::Window* insert = source;
+    aura::Window* target_to_insert = target;
     if (source_ws_index < target_ws_index) {
       for (int i = target_ws_index; i >= source_ws_index; --i) {
         insert = workspaces_[i]->ShiftWindows(
-            insert, source, target, Workspace::SHIFT_TO_LEFT);
+            insert, source, target_to_insert, Workspace::SHIFT_TO_LEFT);
         // |target| can only be in the 1st workspace.
-        target = NULL;
+        target_to_insert = NULL;
       }
     } else {
       for (int i = target_ws_index; i <= source_ws_index; ++i) {
         insert = workspaces_[i]->ShiftWindows(
-            insert, source, target, Workspace::SHIFT_TO_RIGHT);
+            insert, source, target_to_insert, Workspace::SHIFT_TO_RIGHT);
         // |target| can only be in the 1st workspace.
-        target = NULL;
+        target_to_insert = NULL;
       }
     }
   }
+  FOR_EACH_OBSERVER(WorkspaceObserver, observers_,
+                    WindowMoved(this, source, target));
 }
 
 void WorkspaceManager::SetWorkspaceSize(const gfx::Size& workspace_size) {
   if (workspace_size == workspace_size_)
     return;
   workspace_size_ = workspace_size;
   LayoutWorkspaces();
 }
 
+void WorkspaceManager::AddObserver(WorkspaceObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void WorkspaceManager::RemoveObserver(WorkspaceObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WorkspaceManager, private:
 
 void WorkspaceManager::AddWorkspace(Workspace* workspace) {
   Workspaces::iterator i = std::find(workspaces_.begin(),
                                      workspaces_.end(),
                                      workspace);
   DCHECK(i == workspaces_.end());
   workspaces_.push_back(workspace);
 }
 
 void WorkspaceManager::RemoveWorkspace(Workspace* workspace) {
   Workspaces::iterator i = std::find(workspaces_.begin(),
                                      workspaces_.end(),
                                      workspace);
   DCHECK(i != workspaces_.end());
-  if (workspace == active_workspace_)
+  Workspace* old = NULL;
+
+  if (workspace == active_workspace_) {
+    old = active_workspace_;
     active_workspace_ = NULL;
+  }
   workspaces_.erase(i);
   LayoutWorkspaces();
+
+  if (old) {
+    FOR_EACH_OBSERVER(WorkspaceObserver, observers_,
+                      ActiveWorkspaceChanged(this, old));
+  }
 }
 
 void WorkspaceManager::SetActiveWorkspace(Workspace* workspace) {
   DCHECK(std::find(workspaces_.begin(), workspaces_.end(),
                    workspace) != workspaces_.end());
+  Workspace* old = active_workspace_;
   active_workspace_ = workspace;
 
   is_overview_ = false;
   UpdateViewport();
+
+  FOR_EACH_OBSERVER(WorkspaceObserver, observers_,
+                    ActiveWorkspaceChanged(this, old));
 }
 
 gfx::Rect WorkspaceManager::GetWorkAreaBounds(
     const gfx::Rect& workspace_bounds) {
   gfx::Rect bounds = workspace_bounds;
   bounds.Inset(
       aura::Desktop::GetInstance()->screen()->work_area_insets());
   return bounds;
 }
 
@@ skipping 22 matching lines @@
     ui::Transform transform;
     transform.SetTranslateX(-active_workspace_->bounds().x());
     ui::LayerAnimator::ScopedSettings settings(
         viewport_->layer()->GetAnimator());
     viewport_->SetTransform(transform);
   }
 }
 
 }  // namespace internal
 }  // namespace aura_shell