Revert 132144 - Broke ASAN

chrome/browser/ui/panels/panel_manager.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_PANEL_MANAGER_H_
 #define CHROME_BROWSER_UI_PANELS_PANEL_MANAGER_H_
 #pragma once
 
 #include <vector>
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/timer.h"
 #include "chrome/browser/ui/panels/display_settings_provider.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_constants.h"
 #include "chrome/browser/ui/panels/panel_strip.h"
 #include "ui/gfx/rect.h"
 
 class Browser;
 class DetachedPanelStrip;
 class DockedPanelStrip;
 class OverflowPanelStrip;
 class PanelDragController;
 class PanelResizeController;
 class PanelMouseWatcher;
 
 // This class manages a set of panels.
-class PanelManager : public DisplaySettingsProvider::DisplayAreaObserver,
-                     public DisplaySettingsProvider::FullScreenObserver {
+class PanelManager : public DisplaySettingsProvider::DisplayAreaObserver {
  public:
   // Returns a single instance.
   static PanelManager* GetInstance();
 
   // Returns true if panels should be used for the extension.
   static bool ShouldUsePanels(const std::string& extension_id);
 
   // Creates a panel and returns it. The panel might be queued for display
   // later.
   Panel* CreatePanel(Browser* browser);
@@ skipping 77 matching lines @@
   }
 
   DetachedPanelStrip* detached_strip() const {
     return detached_strip_.get();
   }
 
   DockedPanelStrip* docked_strip() const {
     return docked_strip_.get();
   }
 
+  bool is_full_screen() const { return is_full_screen_; }
   OverflowPanelStrip* overflow_strip() const {
     return overflow_strip_.get();
   }
 
   // Width of the overflow strip in compact state i.e mouse not hovering over.
   int overflow_strip_width() const;
 
   // Reduces time interval in tests to shorten test run time.
   // Wrapper should be used around all time intervals in panels code.
   static inline double AdjustTimeInterval(double interval) {
@@ skipping 34 matching lines @@
 
  private:
   friend struct base::DefaultLazyInstanceTraits<PanelManager>;
 
   PanelManager();
   virtual ~PanelManager();
 
   // Overridden from DisplaySettingsProvider::DisplayAreaObserver:
   virtual void OnDisplayAreaChanged(const gfx::Rect& display_area) OVERRIDE;
 
-  // Overridden from DisplaySettingsProvider::FullScreenObserver:
-  virtual void OnFullScreenModeChanged(bool is_full_screen) OVERRIDE;
+  // Tests if the current active app is in full screen mode.
+  void CheckFullScreenMode();
 
   // Tests may want to use a mock panel mouse watcher.
   void SetMouseWatcher(PanelMouseWatcher* watcher);
 
   // Tests may want to shorten time intervals to reduce running time.
   static bool shorten_time_intervals_;
 
   scoped_ptr<DetachedPanelStrip> detached_strip_;
   scoped_ptr<DockedPanelStrip> docked_strip_;
   scoped_ptr<OverflowPanelStrip> overflow_strip_;
 
   scoped_ptr<PanelDragController> drag_controller_;
   scoped_ptr<PanelResizeController> resize_controller_;
 
   // Use a mouse watcher to know when to bring up titlebars to "peek" at
   // minimized panels. Mouse movement is only tracked when there is a minimized
   // panel.
   scoped_ptr<PanelMouseWatcher> panel_mouse_watcher_;
 
   scoped_ptr<DisplaySettingsProvider> display_settings_provider_;
 
   // Whether or not bounds will be updated when the preferred content size is
   // changed. The testing code could set this flag to false so that other tests
   // will not be affected.
   bool auto_sizing_enabled_;
 
+  // Timer used to track if the current active app is in full screen mode.
+  base::RepeatingTimer<PanelManager> full_screen_mode_timer_;
+
+  // True if current active app is in full screen mode.
+  bool is_full_screen_;
+
   // True only while moving panels to overflow. Used to prevent moving panels
   // out of overflow while in the process of moving panels to overflow.
   bool is_processing_overflow_;
 
   DISALLOW_COPY_AND_ASSIGN(PanelManager);
 };
 
 #endif  // CHROME_BROWSER_UI_PANELS_PANEL_MANAGER_H_