Save and restore unified mode

chrome/browser/chromeos/display/display_preferences_unittest.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/chromeos/display/display_preferences.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/content/display/screen_orientation_controller_chromeos.h"
@@ skipping 31 matching lines @@
 
 // The mean acceleration due to gravity on Earth in m/s^2.
 const float kMeanGravity = 9.80665f;
 
 bool IsRotationLocked() {
   return ash::Shell::GetInstance()
       ->screen_orientation_controller()
       ->rotation_locked();
 }
 
+std::string ToPairString(const ash::DisplayIdPair& pair) {
+  return base::Int64ToString(pair.first) + "," +
+         base::Int64ToString(pair.second);
+}
+
 class DisplayPreferencesTest : public ash::test::AshTestBase {
  protected:
   DisplayPreferencesTest()
       : mock_user_manager_(new MockUserManager),
         user_manager_enabler_(mock_user_manager_) {
   }
 
   ~DisplayPreferencesTest() override {}
 
   void SetUp() override {
@@ skipping 23 matching lines @@
     EXPECT_CALL(*mock_user_manager_, IsUserLoggedIn())
         .WillRepeatedly(testing::Return(true));
     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsUserWithGaiaAccount())
         .WillRepeatedly(testing::Return(false));
     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsSupervisedUser())
         .WillRepeatedly(testing::Return(false));
   }
 
   // Do not use the implementation of display_preferences.cc directly to avoid
   // notifying the update to the system.
-  void StoreDisplayLayoutPrefForName(const std::string& name,
+  void StoreDisplayLayoutPrefForPair(const ash::DisplayIdPair& pair,
                                      ash::DisplayLayout::Position layout,
                                      int offset,
                                      int64 primary_id) {
+    std::string name = ToPairString(pair);
     DictionaryPrefUpdate update(&local_state_, prefs::kSecondaryDisplays);
     ash::DisplayLayout display_layout(layout, offset);
     display_layout.primary_id = primary_id;
 
     DCHECK(!name.empty());
 
     base::DictionaryValue* pref_data = update.Get();
     scoped_ptr<base::Value>layout_value(new base::DictionaryValue());
     if (pref_data->HasKey(name)) {
       base::Value* value = NULL;
       if (pref_data->Get(name, &value) && value != NULL)
         layout_value.reset(value->DeepCopy());
     }
     if (ash::DisplayLayout::ConvertToValue(display_layout, layout_value.get()))
       pref_data->Set(name, layout_value.release());
   }
 
-  void StoreDisplayLayoutPrefForPair(int64 id1,
-                                     int64 id2,
+  void StoreDisplayPropertyForPair(const ash::DisplayIdPair& pair,
+                                   std::string key,
+                                   scoped_ptr<base::Value> value) {
+    std::string name = ToPairString(pair);
+
+    DictionaryPrefUpdate update(&local_state_, prefs::kSecondaryDisplays);
+    base::DictionaryValue* pref_data = update.Get();
+
+    if (pref_data->HasKey(name)) {
+      base::Value* layout_value = NULL;
+      pref_data->Get(name, &layout_value);
+      if (layout_value)
+        static_cast<base::DictionaryValue*>(layout_value)
+            ->Set(key, value.Pass());
+    } else {
+      scoped_ptr<base::DictionaryValue> layout_value(
+          new base::DictionaryValue());
+      layout_value->SetBoolean(key, value);
+      pref_data->Set(name, layout_value.release());
+    }
+  }
+
+  void StoreDisplayBoolPropertyForPair(const ash::DisplayIdPair& pair,
+                                       const std::string& key,
+                                       bool value) {
+    StoreDisplayPropertyForPair(
+        pair, key, make_scoped_ptr(new base::FundamentalValue(value)));
+  }
+
+  void StoreDisplayLayoutPrefForPair(const ash::DisplayIdPair& pair,
                                      ash::DisplayLayout::Position layout,
                                      int offset) {
-    StoreDisplayLayoutPrefForName(
-        base::Int64ToString(id1) + "," + base::Int64ToString(id2),
-        layout, offset, id1);
-  }
-
-  void StoreDisplayLayoutPrefForSecondary(int64 id,
-                                          ash::DisplayLayout::Position layout,
-                                          int offset,
-                                          int64 primary_id) {
-    StoreDisplayLayoutPrefForName(
-        base::Int64ToString(id), layout, offset, primary_id);
+    StoreDisplayLayoutPrefForPair(pair, layout, offset, pair.first);
   }
 
   void StoreDisplayOverscan(int64 id, const gfx::Insets& insets) {
     DictionaryPrefUpdate update(&local_state_, prefs::kDisplayProperties);
     const std::string name = base::Int64ToString(id);
 
     base::DictionaryValue* pref_data = update.Get();
     base::DictionaryValue* insets_value = new base::DictionaryValue();
     insets_value->SetInteger("insets_top", insets.top());
     insets_value->SetInteger("insets_left", insets.left());
@@ skipping 13 matching lines @@
   }
 
   void StoreDisplayRotationPrefsForTest(bool rotation_lock,
                                         gfx::Display::Rotation rotation) {
     DictionaryPrefUpdate update(local_state(), prefs::kDisplayRotationLock);
     base::DictionaryValue* pref_data = update.Get();
     pref_data->SetBoolean("lock", rotation_lock);
     pref_data->SetInteger("orientation", static_cast<int>(rotation));
   }
 
-  std::string GetRegisteredDisplayLayoutStr(int64 id1, int64 id2) {
-    ash::DisplayIdPair pair;
-    pair.first = id1;
-    pair.second = id2;
+  std::string GetRegisteredDisplayLayoutStr(const ash::DisplayIdPair& pair) {
     return ash::Shell::GetInstance()->display_manager()->layout_store()->
         GetRegisteredDisplayLayout(pair).ToString();
   }
 
   PrefService* local_state() { return &local_state_; }
 
  private:
   MockUserManager* mock_user_manager_;  // Not owned.
   ScopedUserManagerEnabler user_manager_enabler_;
   TestingPrefServiceSimple local_state_;
   scoped_ptr<DisplayConfigurationObserver> observer_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayPreferencesTest);
 };
 
 }  // namespace
 
 TEST_F(DisplayPreferencesTest, PairedLayoutOverrides) {
   UpdateDisplay("100x100,200x200");
-  int64 id1 = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id();
-  int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
-  int64 dummy_id = id2 + 1;
-  ASSERT_NE(id1, dummy_id);
+  ash::DisplayManager* display_manager =
+      ash::Shell::GetInstance()->display_manager();
 
-  StoreDisplayLayoutPrefForPair(id1, id2, ash::DisplayLayout::TOP, 20);
-  StoreDisplayLayoutPrefForPair(id1, dummy_id, ash::DisplayLayout::LEFT, 30);
+  ash::DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
+  ash::DisplayIdPair dummy_pair = std::make_pair(pair.first, pair.second + 1);
+  ASSERT_NE(pair.first, dummy_pair.second);
+
+  StoreDisplayLayoutPrefForPair(pair, ash::DisplayLayout::TOP, 20);
+  StoreDisplayLayoutPrefForPair(dummy_pair, ash::DisplayLayout::LEFT, 30);
   StoreDisplayPowerStateForTest(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON);
 
   ash::Shell* shell = ash::Shell::GetInstance();
 
   LoadDisplayPreferences(true);
   // DisplayPowerState should be ignored at boot.
   EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_ON,
             shell->display_configurator()->requested_power_state());
 
   shell->display_manager()->UpdateDisplays();
   // Check if the layout settings are notified to the system properly.
   // The paired layout overrides old layout.
   // Inverted one of for specified pair (id1, id2).  Not used for the pair
   // (id1, dummy_id) since dummy_id is not connected right now.
   EXPECT_EQ("top, 20",
             shell->display_manager()->GetCurrentDisplayLayout().ToString());
-  EXPECT_EQ("top, 20", GetRegisteredDisplayLayoutStr(id1, id2));
-  EXPECT_EQ("left, 30", GetRegisteredDisplayLayoutStr(id1, dummy_id));
+  EXPECT_EQ("top, 20", GetRegisteredDisplayLayoutStr(pair));
+  EXPECT_EQ("left, 30", GetRegisteredDisplayLayoutStr(dummy_pair));
 }
 
 TEST_F(DisplayPreferencesTest, BasicStores) {
   ash::DisplayController* display_controller =
       ash::Shell::GetInstance()->display_controller();
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
 
   UpdateDisplay("200x200*2, 400x300#400x400|300x200*1.25");
   int64 id1 = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id();
@@ skipping 624 matching lines @@
       true);
 
   EXPECT_TRUE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   const base::DictionaryValue* properties =
       local_state()->GetDictionary(prefs::kDisplayRotationLock);
   bool rotation_lock;
   EXPECT_TRUE(properties->GetBoolean("lock", &rotation_lock));
 }
 
+TEST_F(DisplayPreferencesTest, SaveUnifiedMode) {
+  UpdateDisplay("100x100,200x200");
+  LoggedInAsUser();
+  ash::DisplayManager* display_manager =
+      ash::Shell::GetInstance()->display_manager();
+  ash::DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
+  std::string pair_key = ToPairString(pair);
+
+  // Unified mode should be recorded.
+  display_manager->SetDefaultMultiDisplayMode(ash::DisplayManager::UNIFIED);
+  display_manager->ReconfigureDisplays();
+
+  const base::DictionaryValue* displays =
+      local_state()->GetDictionary(prefs::kSecondaryDisplays);
+  const base::DictionaryValue* new_value = NULL;
+  EXPECT_TRUE(displays->GetDictionary(ToPairString(pair), &new_value));
+
+  ash::DisplayLayout stored_layout;
+  EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
+  EXPECT_TRUE(stored_layout.default_unified);
+  EXPECT_FALSE(stored_layout.mirrored);
+
+  // Mirror mode should remember if the default mode was unified.
+  display_manager->SetMirrorMode(true);
+  EXPECT_TRUE(displays->GetDictionary(ToPairString(pair), &new_value));
+  EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
+  EXPECT_TRUE(stored_layout.default_unified);
+  EXPECT_TRUE(stored_layout.mirrored);
+
+  display_manager->SetMirrorMode(false);
+  EXPECT_TRUE(displays->GetDictionary(ToPairString(pair), &new_value));
+  EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
+  EXPECT_TRUE(stored_layout.default_unified);
+  EXPECT_FALSE(stored_layout.mirrored);
+
+  // Exit unified mode.
+  display_manager->SetDefaultMultiDisplayMode(ash::DisplayManager::EXTENDED);
+  display_manager->ReconfigureDisplays();
+  EXPECT_TRUE(displays->GetDictionary(ToPairString(pair), &new_value));
+  EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
+  EXPECT_FALSE(stored_layout.default_unified);
+  EXPECT_FALSE(stored_layout.mirrored);
+}
+
+TEST_F(DisplayPreferencesTest, RestoreUnifiedMode) {
+  int64 id1 = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id();
+  ash::DisplayIdPair pair = std::make_pair(id1, id1 + 1);
+  StoreDisplayBoolPropertyForPair(pair, "default_unified", true);
+  StoreDisplayPropertyForPair(
+      pair, "primary-id",
+      make_scoped_ptr(new base::StringValue(base::Int64ToString(id1))));
+  LoadDisplayPreferences(false);
+
+  // Should not restore to unified unless unified desktop is enabled.
+  UpdateDisplay("100x100,200x200");
+  ash::DisplayManager* display_manager =
+      ash::Shell::GetInstance()->display_manager();
+  EXPECT_FALSE(display_manager->IsInUnifiedMode());
+
+  // Restored to unified.
+  ash::test::DisplayManagerTestApi::EnableUnifiedDesktopForTest();
+  StoreDisplayBoolPropertyForPair(pair, "default_unified", true);
+  LoadDisplayPreferences(false);
+  UpdateDisplay("100x100,200x200");
+  EXPECT_TRUE(display_manager->IsInUnifiedMode());
+
+  // Restored to mirror, then unified.
+  StoreDisplayBoolPropertyForPair(pair, "mirrored", true);
+  StoreDisplayBoolPropertyForPair(pair, "default_unified", true);
+  LoadDisplayPreferences(false);
+  UpdateDisplay("100x100,200x200");
+  EXPECT_TRUE(display_manager->IsInMirrorMode());
+
+  display_manager->SetMirrorMode(false);
+  EXPECT_TRUE(display_manager->IsInUnifiedMode());
+
+  // Sanity check. Restore to extended.
+  StoreDisplayBoolPropertyForPair(pair, "default_unified", false);
+  StoreDisplayBoolPropertyForPair(pair, "mirrored", false);
+  LoadDisplayPreferences(false);
+  UpdateDisplay("100x100,200x200");
+  EXPECT_FALSE(display_manager->IsInMirrorMode());
+  EXPECT_FALSE(display_manager->IsInUnifiedMode());
+}
+
 }  // namespace chromeos