[Cleanup] Factor out layout store code from DisplayController

ash/display/display_controller.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/display/display_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 
 #include "ash/ash_switches.h"
+#include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/root_window_transformers.h"
 #include "ash/host/root_window_host_factory.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
@@ skipping 194 matching lines @@
 DisplayController::DisplayController()
     : primary_root_window_for_replace_(NULL),
       in_bootstrap_(true),
       focus_activation_store_(new internal::FocusActivationStore()) {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 #if defined(OS_CHROMEOS)
   if (!command_line->HasSwitch(switches::kAshDisableDisplayChangeLimiter) &&
       base::chromeos::IsRunningOnChromeOS())
     limiter_.reset(new DisplayChangeLimiter);
 #endif
-  if (command_line->HasSwitch(switches::kAshSecondaryDisplayLayout)) {
-    std::string value = command_line->GetSwitchValueASCII(
-        switches::kAshSecondaryDisplayLayout);
-    char layout;
-    int offset = 0;
-    if (sscanf(value.c_str(), "%c,%d", &layout, &offset) == 2) {
-      if (layout == 't')
-        default_display_layout_.position = DisplayLayout::TOP;
-      else if (layout == 'b')
-        default_display_layout_.position = DisplayLayout::BOTTOM;
-      else if (layout == 'r')
-        default_display_layout_.position = DisplayLayout::RIGHT;
-      else if (layout == 'l')
-        default_display_layout_.position = DisplayLayout::LEFT;
-      default_display_layout_.offset = offset;
-    }
-  }
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
   primary_display_id = gfx::Display::kInvalidDisplayID;
   delete primary_display_for_shutdown;
   primary_display_for_shutdown = NULL;
   num_displays_for_shutdown = -1;
 }
 
 DisplayController::~DisplayController() {
   DCHECK(primary_display_for_shutdown);
@@ skipping 129 matching lines @@
   for (std::map<int64, aura::RootWindow*>::const_iterator it =
            root_windows_.begin(); it != root_windows_.end(); ++it) {
     internal::RootWindowController* controller =
         GetRootWindowController(it->second);
     if (controller)
       controllers.push_back(controller);
   }
   return controllers;
 }
 
-void DisplayController::SetDefaultDisplayLayout(const DisplayLayout& layout) {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (!command_line->HasSwitch(switches::kAshSecondaryDisplayLayout))
-    default_display_layout_ = layout;
-}
-
-void DisplayController::RegisterLayoutForDisplayIdPair(
-    int64 id1,
-    int64 id2,
-    const DisplayLayout& layout) {
-  RegisterLayoutForDisplayIdPairInternal(id1, id2, layout, true);
-}
-
 void DisplayController::SetLayoutForCurrentDisplays(
     const DisplayLayout& layout_relative_to_primary) {
   DCHECK_EQ(2U, GetDisplayManager()->GetNumDisplays());
   if (GetDisplayManager()->GetNumDisplays() < 2)
     return;
   const gfx::Display& primary = GetPrimaryDisplay();
   const DisplayIdPair pair = GetCurrentDisplayIdPair();
   // Invert if the primary was swapped.
   DisplayLayout to_set = pair.first == primary.id() ?
       layout_relative_to_primary : layout_relative_to_primary.Invert();
 
-  const DisplayLayout& current_layout = paired_layouts_[pair];
+  internal::DisplayLayoutStore* layout_store =
+      GetDisplayManager()->layout_store();
+  DisplayLayout current_layout =
+      layout_store->GetRegisteredDisplayLayout(pair);
   if (to_set.position != current_layout.position ||
       to_set.offset != current_layout.offset) {
     to_set.primary_id = primary.id();
-    paired_layouts_[pair] = to_set;
+    layout_store->RegisterLayoutForDisplayIdPair(
+        pair.first, pair.second, to_set);
     NotifyDisplayConfigurationChanging();
     // TODO(oshima): Call UpdateDisplays instead.
     UpdateDisplayBoundsForLayout();
     NotifyDisplayConfigurationChanged();
   }
 }
 
 DisplayLayout DisplayController::GetCurrentDisplayLayout() {
   DCHECK_EQ(2U, GetDisplayManager()->num_connected_displays());
   // Invert if the primary was swapped.
   if (GetDisplayManager()->num_connected_displays() > 1) {
     DisplayIdPair pair = GetCurrentDisplayIdPair();
-    return ComputeDisplayLayoutForDisplayIdPair(pair);
+    return GetDisplayManager()->layout_store()->
+        ComputeDisplayLayoutForDisplayIdPair(pair);
   }
+  NOTREACHED() << "DisplayLayout is requested for single display";
   // On release build, just fallback to default instead of blowing up.
-  DisplayLayout layout = default_display_layout_;
+  DisplayLayout layout =
+      GetDisplayManager()->layout_store()->default_display_layout();
   layout.primary_id = primary_display_id;
   return layout;
 }
 
 DisplayIdPair DisplayController::GetCurrentDisplayIdPair() const {
   internal::DisplayManager* display_manager = GetDisplayManager();
   const gfx::Display& primary = GetPrimaryDisplay();
   if (display_manager->IsMirrored()) {
     return std::make_pair(primary.id(),
                           display_manager->mirrored_display().id());
   }
 
   const gfx::Display& secondary = ScreenAsh::GetSecondaryDisplay();
   if (primary.IsInternal() ||
       GetDisplayManager()->first_display_id() == primary.id()) {
     return std::make_pair(primary.id(), secondary.id());
   } else {
     // Display has been Swapped.
     return std::make_pair(secondary.id(), primary.id());
   }
 }
 
-DisplayLayout DisplayController::GetRegisteredDisplayLayout(
-    const DisplayIdPair& pair) {
-  std::map<DisplayIdPair, DisplayLayout>::const_iterator iter =
-      paired_layouts_.find(pair);
-  return
-      iter != paired_layouts_.end() ? iter->second : CreateDisplayLayout(pair);
-}
-
 void DisplayController::ToggleMirrorMode() {
   internal::DisplayManager* display_manager = GetDisplayManager();
   if (display_manager->num_connected_displays() <= 1)
     return;
 
   if (limiter_) {
     if  (limiter_->IsThrottled())
       return;
     limiter_->SetThrottleTimeout(kCycleDisplayThrottleTimeoutMs);
   }
@@ skipping 75 matching lines @@
   DCHECK_NE(primary_root, non_primary_root);
 
   root_windows_[new_primary_display.id()] = primary_root;
   primary_root->SetProperty(internal::kDisplayIdKey, new_primary_display.id());
 
   root_windows_[old_primary_display.id()] = non_primary_root;
   non_primary_root->SetProperty(internal::kDisplayIdKey,
                                 old_primary_display.id());
 
   primary_display_id = new_primary_display.id();
-  paired_layouts_[GetCurrentDisplayIdPair()].primary_id = primary_display_id;
+  GetDisplayManager()->layout_store()->UpdatePrimaryDisplayId(
+      GetCurrentDisplayIdPair(), primary_display_id);
 
   display_manager->UpdateWorkAreaOfDisplayNearestWindow(
       primary_root, old_primary_display.GetWorkAreaInsets());
   display_manager->UpdateWorkAreaOfDisplayNearestWindow(
       non_primary_root, new_primary_display.GetWorkAreaInsets());
 
   // Update the dispay manager with new display info.
   std::vector<internal::DisplayInfo> display_info_list;
   display_info_list.push_back(display_manager->GetDisplayInfo(
       primary_display_id));
@@ skipping 214 matching lines @@
 void DisplayController::NotifyDisplayConfigurationChanged() {
   if (in_bootstrap())
     return;
 
   if (limiter_)
     limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
 
   focus_activation_store_->Restore();
 
   internal::DisplayManager* display_manager = GetDisplayManager();
+  internal::DisplayLayoutStore* layout_store = display_manager->layout_store();
   if (display_manager->num_connected_displays() > 1) {
     DisplayIdPair pair = GetCurrentDisplayIdPair();
-    if (paired_layouts_.find(pair) == paired_layouts_.end())
-      CreateDisplayLayout(pair);
-    paired_layouts_[pair].mirrored = display_manager->IsMirrored();
+    layout_store->UpdateMirrorStatus(pair, display_manager->IsMirrored());
+    DisplayLayout layout = layout_store->GetRegisteredDisplayLayout(pair);
+
     if (Shell::GetScreen()->GetNumDisplays() > 1 ) {
-      int64 primary_id = paired_layouts_[pair].primary_id;
+      int64 primary_id = layout.primary_id;
       SetPrimaryDisplayId(
           primary_id == gfx::Display::kInvalidDisplayID ?
           pair.first : primary_id);
       // Update the primary_id in case the above call is
       // ignored. Happens when a) default layout's primary id
       // doesn't exist, or b) the primary_id has already been
       // set to the same and didn't update it.
-      paired_layouts_[pair].primary_id = GetPrimaryDisplay().id();
+      layout_store->UpdatePrimaryDisplayId(pair, GetPrimaryDisplay().id());
     }
   }
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanged());
   UpdateHostWindowNames();
 }
 
-void DisplayController::RegisterLayoutForDisplayIdPairInternal(
-    int64 id1,
-    int64 id2,
-    const DisplayLayout& layout,
-    bool override) {
-  DisplayIdPair pair = std::make_pair(id1, id2);
-  if (override || paired_layouts_.find(pair) == paired_layouts_.end())
-    paired_layouts_[pair] = layout;
-}
-
 void DisplayController::OnFadeOutForSwapDisplayFinished() {
 #if defined(OS_CHROMEOS) && defined(USE_X11)
   SetPrimaryDisplay(ScreenAsh::GetSecondaryDisplay());
   Shell::GetInstance()->output_configurator_animation()->StartFadeInAnimation();
 #endif
 }
 
-DisplayLayout DisplayController::ComputeDisplayLayoutForDisplayIdPair(
-    const DisplayIdPair& pair) {
-  DisplayLayout layout = GetRegisteredDisplayLayout(pair);
-  int64 primary_id = layout.primary_id;
-  // TODO(oshima): replace this with DCHECK.
-  if (primary_id == gfx::Display::kInvalidDisplayID)
-    primary_id = GetPrimaryDisplay().id();
-  // Invert if the primary was swapped. If mirrored, first is always
-  // primary.
-  return pair.first == primary_id ? layout : layout.Invert();
-}
-
 void DisplayController::UpdateHostWindowNames() {
 #if defined(USE_X11)
   // crbug.com/120229 - set the window title for the primary dislpay
   // to "aura_root_0" so gtalk can find the primary root window to broadcast.
   // TODO(jhorwich) Remove this once Chrome supports window-based broadcasting.
   aura::RootWindow* primary = Shell::GetPrimaryRootWindow();
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   for (size_t i = 0; i < root_windows.size(); ++i) {
     std::string name =
         root_windows[i] == primary ? "aura_root_0" : "aura_root_x";
     gfx::AcceleratedWidget xwindow = root_windows[i]->GetAcceleratedWidget();
     XStoreName(ui::GetXDisplay(), xwindow, name.c_str());
   }
 #endif
 }
 
-DisplayLayout DisplayController::CreateDisplayLayout(
-    const DisplayIdPair& pair) {
-  DisplayLayout layout = default_display_layout_;
-  layout.primary_id = pair.first;
-  paired_layouts_[pair] = layout;
-  return layout;
-}
-
 }  // namespace ash