Move full-screen detection logic from PanelManager to DisplaySettingsProvider.

chrome/browser/ui/panels/panel_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 "chrome/browser/ui/panels/panel_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "chrome/browser/fullscreen.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/panels/detached_panel_strip.h"
 #include "chrome/browser/ui/panels/docked_panel_strip.h"
 #include "chrome/browser/ui/panels/overflow_panel_strip.h"
 #include "chrome/browser/ui/panels/panel_drag_controller.h"
 #include "chrome/browser/ui/panels/panel_mouse_watcher.h"
 #include "chrome/browser/ui/panels/panel_resize_controller.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 
 #if defined(TOOLKIT_GTK)
 #include "ui/base/x/x11_util.h"
 #endif
 
 namespace {
 const int kOverflowStripThickness = 26;
 
 // Width of spacing around panel strip and the left/right edges of the screen.
 const int kPanelStripLeftMargin = kOverflowStripThickness + 6;
 const int kPanelStripRightMargin = 24;
 
 // Height of panel strip is based on the factor of the working area.
 const double kPanelStripHeightFactor = 0.5;
-
-static const int kFullScreenModeCheckIntervalMs = 1000;
-
 }  // namespace
 
 // static
 bool PanelManager::shorten_time_intervals_ = false;
 
 // static
 PanelManager* PanelManager::GetInstance() {
   static base::LazyInstance<PanelManager> instance = LAZY_INSTANCE_INITIALIZER;
   return instance.Pointer();
 }
@@ skipping 22 matching lines @@
         extension_id == std::string("ppleadejekpmccmnpjdimmlfljlkdfej") ||
         extension_id == std::string("eggnbpckecmjlblplehfpjjdhhidfdoj");
   }
 
   return true;
 }
 
 PanelManager::PanelManager()
     : panel_mouse_watcher_(PanelMouseWatcher::Create()),
       auto_sizing_enabled_(true),
-      is_full_screen_(false),
       is_processing_overflow_(false) {
   // DisplaySettingsProvider should be created before the creation of strips
   // since some strip might depend on it.
   display_settings_provider_.reset(DisplaySettingsProvider::Create());
-  display_settings_provider_->set_display_area_observer(this);
+  display_settings_provider_->AddObserver(
+      static_cast<DisplaySettingsProvider::DisplayAreaObserver*>(this));
 
   detached_strip_.reset(new DetachedPanelStrip(this));
   docked_strip_.reset(new DockedPanelStrip(this));
   overflow_strip_.reset(new OverflowPanelStrip(this));
   drag_controller_.reset(new PanelDragController(this));
   resize_controller_.reset(new PanelResizeController(this));
 }
 
 PanelManager::~PanelManager() {
+  display_settings_provider_->RemoveObserver(
+      static_cast<DisplaySettingsProvider::DisplayAreaObserver*>(this));
 }
 
 void PanelManager::OnDisplayAreaChanged(const gfx::Rect& display_area) {
   int height =
       static_cast<int>(display_area.height() * kPanelStripHeightFactor);
   gfx::Rect docked_strip_bounds;
   docked_strip_bounds.set_x(display_area.x() + kPanelStripLeftMargin);
   docked_strip_bounds.set_y(display_area.bottom() - height);
   docked_strip_bounds.set_width(display_area.width() -
                                 kPanelStripLeftMargin - kPanelStripRightMargin);
   docked_strip_bounds.set_height(height);
   docked_strip_->SetDisplayArea(docked_strip_bounds);
 
   gfx::Rect overflow_area(display_area);
   overflow_area.set_width(kOverflowStripThickness);
   overflow_strip_->SetDisplayArea(overflow_area);
 }
 
+void PanelManager::OnFullScreenModeChanged(bool is_full_screen) {
+  docked_strip_->OnFullScreenModeChanged(is_full_screen);
+  overflow_strip_->OnFullScreenModeChanged(is_full_screen);
+}
+
 Panel* PanelManager::CreatePanel(Browser* browser) {
   // Need to sync the display area if no panel is present. This is because:
   // 1) Display area is not initialized until first panel is created.
   // 2) On windows, display settings notification is tied to a window. When
   //    display settings are changed at the time that no panel exists, we do
   //    not receive any notification.
   if (num_panels() == 0)
     display_settings_provider_->OnDisplaySettingsChanged();
 
   int width = browser->override_bounds().width();
   int height = browser->override_bounds().height();
   Panel* panel = new Panel(browser, gfx::Size(width, height));
   docked_strip_->AddPanel(panel, PanelStrip::DEFAULT_POSITION);
   docked_strip_->UpdatePanelOnStripChange(panel);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_ADDED,
       content::Source<Panel>(panel),
       content::NotificationService::NoDetails());
 
   if (num_panels() == 1) {
-    full_screen_mode_timer_.Start(FROM_HERE,
-        base::TimeDelta::FromMilliseconds(kFullScreenModeCheckIntervalMs),
-        this, &PanelManager::CheckFullScreenMode);
+    display_settings_provider_->AddObserver(
+        static_cast<DisplaySettingsProvider::FullScreenObserver*>(this));

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

These casts will also go away if observers are not derived from the same base
class and there are 3 separate AddXXXObserver() methods with specific types.

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

Done.

   }
 
   return panel;
 }
 
-void PanelManager::CheckFullScreenMode() {
-  bool is_full_screen_new = IsFullScreenMode();
-  if (is_full_screen_ == is_full_screen_new)
-    return;
-  is_full_screen_ = is_full_screen_new;
-  docked_strip_->OnFullScreenModeChanged(is_full_screen_);
-  overflow_strip_->OnFullScreenModeChanged(is_full_screen_);
-}
-
 void PanelManager::OnPanelClosed(Panel* panel) {
-  if (num_panels() == 1)
-    full_screen_mode_timer_.Stop();
+  if (num_panels() == 1) {
+    display_settings_provider_->RemoveObserver(
+        static_cast<DisplaySettingsProvider::FullScreenObserver*>(this));
+  }
 
   drag_controller_->OnPanelClosed(panel);
   resize_controller_->OnPanelClosed(panel);
   panel->panel_strip()->RemovePanel(panel);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_CLOSED,
       content::Source<Panel>(panel),
       content::NotificationService::NoDetails());
 }
@@ skipping 181 matching lines @@
   return panels;
 }
 
 int PanelManager::overflow_strip_width() const {
   return kOverflowStripThickness;
 }
 
 void PanelManager::SetMouseWatcher(PanelMouseWatcher* watcher) {
   panel_mouse_watcher_.reset(watcher);
 }