Move full-screen detection logic from PanelManager to DisplaySettingsProvider.

chrome/browser/ui/panels/display_settings_provider.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_PANELS_DISPLAY_SETTINGS_PROVIDER_H_
 #define CHROME_BROWSER_UI_PANELS_DISPLAY_SETTINGS_PROVIDER_H_
 #pragma once
 
+#include "base/observer_list.h"
+#include "base/timer.h"
 #include "ui/gfx/rect.h"
 
 // Encapsulates the logic to provide display settings support, including the
 // information for:
 // 1) Work area
 // 2) Auto-hiding desktop bars, like Windows taskbar and MacOSX dock.
 class DisplaySettingsProvider {
+ private:
+  enum ObserverType {

[Dmitry Titov, 2012/04/12 00:08:51]

I think it would be simpler to have no base type for 3 observers, and no enum.
Just declare 3 different observer types and 3 different pairs of methods to
add/remove them.
This also will remove switch statements in implementation.  
Internally, there are 3 separate lists anyways...

[jianli, 2012/04/12 00:45:17]

Done.

+    DISPLAY_AREA_OBSERVER,
+    DESKTOP_BAR_OBSERVER,
+    FULL_SCREEN_OBSERVER
+  };
+
+  // Base class for different kinds of observers.
+  class Observer {
+   public:
+    virtual ObserverType type() const = 0;
+  };
+
  public:
   // Indicates which screen edge the desktop bar is aligned to.
   // We do not care about the desktop aligned to the top screen edge.
   enum DesktopBarAlignment {
     DESKTOP_BAR_ALIGNED_BOTTOM = 0,
     DESKTOP_BAR_ALIGNED_LEFT = 1,
     DESKTOP_BAR_ALIGNED_RIGHT = 2
   };
 
   // Indicates current visibility state of the desktop bar.
   enum DesktopBarVisibility {
     DESKTOP_BAR_VISIBLE,
     DESKTOP_BAR_ANIMATING,
     DESKTOP_BAR_HIDDEN
   };
 
-  // Observer can listen to the event regarding the display area change.
-  class DisplayAreaObserver {
+  class DisplayAreaObserver : public Observer {
    public:
     virtual void OnDisplayAreaChanged(const gfx::Rect& display_area) = 0;
+   private:
+    virtual ObserverType type() const OVERRIDE { return DISPLAY_AREA_OBSERVER; }
   };
 
-  // Observer can listen to the event regarding the desktop bar change.
-  class DesktopBarObserver {
+  class DesktopBarObserver : public Observer {
    public:
     virtual void OnAutoHidingDesktopBarVisibilityChanged(
         DesktopBarAlignment alignment, DesktopBarVisibility visibility) = 0;
+   private:
+    virtual ObserverType type() const OVERRIDE { return DESKTOP_BAR_OBSERVER; }
+  };
+
+  class FullScreenObserver : public Observer {
+   public:
+    virtual void OnFullScreenModeChanged(bool is_full_screen) = 0;
+   private:
+    virtual ObserverType type() const OVERRIDE { return FULL_SCREEN_OBSERVER; }
   };
 
   static DisplaySettingsProvider* Create();
 
   virtual ~DisplaySettingsProvider();
 
+  // Subscribes/unsubscribes from the display settings change notification.
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
+
   // Returns the bounds of the display area.
   gfx::Rect GetDisplayArea();
 
   // Invoked when the display settings has changed, due to any of the following:
   // 1) screen resolution changes
   // 2) the thickness of desktop bar changes
   // 3) desktop bar switches between auto-hiding and non-auto-hiding
   virtual void OnDisplaySettingsChanged();
 
   // Returns true if there is a desktop bar that is aligned to the specified
   // screen edge and set to auto-hide.
   virtual bool IsAutoHidingDesktopBarEnabled(DesktopBarAlignment alignment);
 
   // Returns the thickness of the desktop bar that is aligned to the specified
   // screen edge, when it is visible. When the desktop bar is aligned to bottom
   // edge, this is the height of the bar. If the desktop bar is aligned to
   // left or right edge, this is the width of the bar.
   virtual int GetDesktopBarThickness(DesktopBarAlignment alignment) const;
 
   // Returns the visibility state of the desktop bar that is aligned to the
   // specified screen edge.
   virtual DesktopBarVisibility GetDesktopBarVisibility(
       DesktopBarAlignment alignment) const;
 
-  DisplayAreaObserver* display_area_observer() const {
-    return display_area_observer_;
-  }
-  void set_display_area_observer(DisplayAreaObserver* display_area_observer) {
-    display_area_observer_ = display_area_observer;
+  ObserverList<DisplayAreaObserver>& display_area_observers() {
+    return display_area_observers_;
   }
 
-  DesktopBarObserver* desktop_bar_observer() const {
-    return desktop_bar_observer_;
+  ObserverList<DesktopBarObserver>& desktop_bar_observers() {
+    return desktop_bar_observers_;
   }
-  void set_desktop_bar_observer(DesktopBarObserver* desktop_bar_observer) {
-    desktop_bar_observer_ = desktop_bar_observer;
+
+  ObserverList<FullScreenObserver>& full_screen_observers() {
+    return full_screen_observers_;
   }
 
   gfx::Rect work_area() const { return work_area_; }
+  bool is_full_screen() const { return is_full_screen_; }
 
  protected:
   DisplaySettingsProvider();
 
   // Returns the bounds of the work area that has not been adjusted to take
   // auto-hiding desktop bars into account. This can be overridden by the
   // testing code.
   virtual gfx::Rect GetWorkArea() const;
 
+  // Callback to perform periodic check for full screen mode changes.
+  virtual void CheckFullScreenMode();
+
   void OnAutoHidingDesktopBarChanged();
 
  private:
   // Adjusts the work area to exclude the influence of auto-hiding desktop bars.
   void AdjustWorkAreaForAutoHidingDesktopBars();
 
-  DisplayAreaObserver* display_area_observer_;
-  DesktopBarObserver* desktop_bar_observer_;
+  // Observers that listen to various display settings changes.
+  ObserverList<DisplayAreaObserver> display_area_observers_;
+  ObserverList<DesktopBarObserver> desktop_bar_observers_;
+  ObserverList<FullScreenObserver> full_screen_observers_;
 
   // The maximum work area avaialble. This area does not include the area taken
   // by the always-visible (non-auto-hiding) desktop bars.
   gfx::Rect work_area_;
 
   // The useable work area for computing the panel bounds. This area excludes
   // the potential area that could be taken by the auto-hiding desktop
   // bars (we only consider those bars that are aligned to bottom, left, and
   // right of the screen edges) when they become fully visible.
   gfx::Rect adjusted_work_area_;
+
+  // True if full screen mode or presentation mode is entered.
+  bool is_full_screen_;
+
+  // Timer used to detect full-screen mode change.
+  base::RepeatingTimer<DisplaySettingsProvider> full_screen_mode_timer_;

[dcheng, 2012/04/12 00:18:28]

Minor nit: DISALLOW_COPY_AND_ASSIGN should be used for all the classes defined
in here.

[jianli, 2012/04/12 00:45:17]

Done.

 };
 
 #endif  // CHROME_BROWSER_UI_PANELS_DISPLAY_SETTINGS_PROVIDER_H_