[Cleanup] Factor out layout store code from DisplayController

ash/display/display_controller.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 ASH_DISPLAY_DISPLAY_CONTROLLER_H_
 #define ASH_DISPLAY_DISPLAY_CONTROLLER_H_
 
 #include <map>
 #include <vector>
 
 #include "ash/ash_export.h"
 #include "ash/display/display_layout.h"

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

display_layout.h include is not necessary anymore

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

This is necessary for DisplayIdPair (which is typedef)
which is used in store, controller and manager.

It's possible to define separate header, or to make it a class
but either way sounds overkill to me.

 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "ui/gfx/display_observer.h"
 
 namespace aura {
 class Display;
@@ skipping 97 matching lines @@
 
   // Returns all oot window controllers. In non extended desktop
   // mode, this return a RootWindowController for the primary root window only.
   std::vector<internal::RootWindowController*> GetAllRootWindowControllers();
 
   // Gets/Sets/Clears the overscan insets for the specified |display_id|. See
   // display_manager.h for the details.
   gfx::Insets GetOverscanInsets(int64 display_id) const;
   void SetOverscanInsets(int64 display_id, const gfx::Insets& insets_in_dip);
 
-  const DisplayLayout& default_display_layout() const {
-    return default_display_layout_;
-  }
-  void SetDefaultDisplayLayout(const DisplayLayout& layout);
-
-  // Registeres the display layout info for the specified display(s).
-  void RegisterLayoutForDisplayIdPair(int64 id1,
-                                      int64 id2,
-                                      const DisplayLayout& layout);
   // Sets the layout for the current display pair. The |layout| specifies
   // the locaion of the secondary display relative to the primary.
   void SetLayoutForCurrentDisplays(const DisplayLayout& layout);
 
   // Returns the display layout used for current displays.
   DisplayLayout GetCurrentDisplayLayout();
 
   // Returns the current display pair.
   DisplayIdPair GetCurrentDisplayIdPair() const;
 
-  // Returns the display layout registered for the given display id |pair|.
-  // If no layout is registered, it creatas new layout using
-  // |default_display_layout_|.
-  DisplayLayout GetRegisteredDisplayLayout(const DisplayIdPair& pair);
-
   // Checks if the mouse pointer is on one of displays, and moves to
   // the center of the nearest display if it's outside of all displays.
   void EnsurePointerInDisplays();
 
   gfx::Point GetNativeMouseCursorLocation() const;
 
   // Update the current cursor image that is sutable for the given
   // |point_in_native|.
   void UpdateMouseCursor(const gfx::Point& point_in_native);
 
@@ skipping 12 matching lines @@
   aura::RootWindow* AddRootWindowForDisplay(const gfx::Display& display);
 
   void UpdateDisplayBoundsForLayout();
 
   void NotifyDisplayConfigurationChanging();
   void NotifyDisplayConfigurationChanged();
 
   void SetLayoutForDisplayIdPair(const DisplayIdPair& display_pair,
                                  const DisplayLayout& layout);
 
-  void RegisterLayoutForDisplayIdPairInternal(
-      int64 id1,
-      int64 id2,
-      const DisplayLayout& layout,
-      bool override);
-
   void OnFadeOutForSwapDisplayFinished();
 
-  // Returns the display layout for the display id pair
-  // with display swapping applied.  That is, this returns
-  // flipped layout if the displays are swapped.
-  DisplayLayout ComputeDisplayLayoutForDisplayIdPair(
-      const DisplayIdPair& display_pair);
-
   void UpdateHostWindowNames();
 
-  // Creates new layout for display pair from |default_display_layout_|.
-  DisplayLayout CreateDisplayLayout(const DisplayIdPair& display_pair);
-
   bool in_bootstrap() const { return in_bootstrap_; }
 
   class DisplayChangeLimiter {
    public:
     DisplayChangeLimiter();
 
     // Sets how long the throttling should last.
     void SetThrottleTimeout(int64 throttle_ms);
 
     bool IsThrottled() const;
 
    private:
     // The time when the throttling ends.
     base::Time throttle_timeout_;
 
     DISALLOW_COPY_AND_ASSIGN(DisplayChangeLimiter);
   };
 
   // The limiter to throttle how fast a user can
   // change the display configuration.
   scoped_ptr<DisplayChangeLimiter> limiter_;
 
   // The mapping from display ID to its root window.
   std::map<int64, aura::RootWindow*> root_windows_;
 
-  // The default display layout.
-  DisplayLayout default_display_layout_;
-
-  // Display layout per pair of devices.
-  std::map<DisplayIdPair, DisplayLayout> paired_layouts_;
-
   ObserverList<Observer> observers_;
 
   // Store the primary root window temporarily while replacing
   // display.
   aura::RootWindow* primary_root_window_for_replace_;
 
   bool in_bootstrap_;
 
   scoped_ptr<internal::FocusActivationStore> focus_activation_store_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayController);
 };
 
 }  // namespace ash
 
 #endif  // ASH_DISPLAY_DISPLAY_CONTROLLER_H_