Polish launcher tooltip visibility (2nd try).

ash/wm/shelf_layout_manager.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/wm/shelf_layout_manager.h"
 
 #include <algorithm>
 
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
@@ skipping 118 matching lines @@
       alignment_(SHELF_ALIGNMENT_BOTTOM),
       launcher_(NULL),
       status_(status),
       workspace_manager_(NULL),
       window_overlaps_shelf_(false) {
   Shell::GetInstance()->AddShellObserver(this);
   aura::client::GetActivationClient(root_window_)->AddObserver(this);
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
+  FOR_EACH_OBSERVER(Observer, observers_, WillDeleteShelf());
   Shell::GetInstance()->RemoveShellObserver(this);
   aura::client::GetActivationClient(root_window_)->RemoveObserver(this);
 }
 
 void ShelfLayoutManager::SetAutoHideBehavior(ShelfAutoHideBehavior behavior) {
   if (auto_hide_behavior_ == behavior)
     return;
   auto_hide_behavior_ = behavior;
   UpdateVisibilityState();
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    OnAutoHideStateChanged(state_.auto_hide_state));
 }
 
 bool ShelfLayoutManager::IsVisible() const {
   return status_->IsVisible() && (state_.visibility_state == VISIBLE ||
       (state_.visibility_state == AUTO_HIDE &&
        state_.auto_hide_state == AUTO_HIDE_SHOWN));
 }
 
 gfx::Rect ShelfLayoutManager::GetMaximizedWindowBounds(
     aura::Window* window) {
@@ skipping 114 matching lines @@
   }
 }
 
 void ShelfLayoutManager::UpdateAutoHideState() {
   AutoHideState auto_hide_state =
       CalculateAutoHideState(state_.visibility_state);
   if (auto_hide_state != state_.auto_hide_state) {
     if (auto_hide_state == AUTO_HIDE_HIDDEN) {
       // Hides happen immediately.
       SetState(state_.visibility_state);
+      FOR_EACH_OBSERVER(Observer, observers_,
+                        OnAutoHideStateChanged(auto_hide_state));
     } else {
       auto_hide_timer_.Stop();
       auto_hide_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kAutoHideDelayMS),
           this, &ShelfLayoutManager::UpdateAutoHideStateNow);
+      FOR_EACH_OBSERVER(Observer, observers_, OnAutoHideStateChanged(
+          CalculateAutoHideState(state_.visibility_state)));
     }
   } else {
     auto_hide_timer_.Stop();
   }
 }
 
 void ShelfLayoutManager::SetWindowOverlapsShelf(bool value) {
   window_overlaps_shelf_ = value;
   UpdateShelfBackground(internal::BackgroundAnimator::CHANGE_ANIMATE);
 }
 
+void ShelfLayoutManager::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ShelfLayoutManager::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, aura::LayoutManager implementation:
 
 void ShelfLayoutManager::OnWindowResized() {
   LayoutShelf();
 }
 
 void ShelfLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
 }
 
@@ skipping 29 matching lines @@
 void ShelfLayoutManager::SetState(VisibilityState visibility_state) {
   ShellDelegate* delegate = Shell::GetInstance()->delegate();
   State state;
   state.visibility_state = visibility_state;
   state.auto_hide_state = CalculateAutoHideState(visibility_state);
   state.is_screen_locked = delegate && delegate->IsScreenLocked();
 
   if (state_.Equals(state))
     return;  // Nothing changed.
 
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    WillChangeVisibilityState(visibility_state));
+
   if (state.visibility_state == AUTO_HIDE) {
     // When state is AUTO_HIDE we need to track when the mouse is over the
     // launcher to unhide the shelf. AutoHideEventFilter does that for us.
     if (!event_filter_.get())
       event_filter_.reset(new AutoHideEventFilter(this));
   } else {
     event_filter_.reset(NULL);
   }
 
   auto_hide_timer_.Stop();
@@ skipping 216 matching lines @@
 int ShelfLayoutManager::GetWorkAreaSize(const State& state, int size) const {
   if (state.visibility_state == VISIBLE)
     return size;
   if (state.visibility_state == AUTO_HIDE)
     return kAutoHideSize;
   return 0;
 }
 
 }  // namespace internal
 }  // namespace ash