[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);
   }
   // 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;

[Jun Mukai, 2013/07/09 16:54:17]

can't we move this setting primary_display_id logic to layout_store?
Not particularly sure, but intuitively it would be the task of the layout store.

[oshima, 2013/07/09 17:27:58]

store doesn't know about the current primary (only knows which is primary for
stored layout), so this needs to stay here.
(notice that this is fallback when default layout is requested
 with single display. I added NOTREACHED to make it clear)

   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