Add ability to set resolution on external display

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 "ash/display/display_controller.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/screen_ash.h"
@@ skipping 165 matching lines @@
   EXPECT_EQ("top, 20", GetRegisteredDisplayLayoutStr(id1, id2));
   EXPECT_EQ("left, 30", GetRegisteredDisplayLayoutStr(id1, dummy_id));
 }
 
 TEST_F(DisplayPreferencesTest, BasicStores) {
   ash::DisplayController* display_controller =
       ash::Shell::GetInstance()->display_controller();
   ash::internal::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
 
-  UpdateDisplay("200x200*2,200x200");
+  UpdateDisplay("200x200*2,400x300");
   int64 id1 = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id();
   gfx::Display::SetInternalDisplayId(id1);
   int64 id2 = ash::ScreenAsh::GetSecondaryDisplay().id();
   int64 dummy_id = id2 + 1;
   ASSERT_NE(id1, dummy_id);
 
   LoggedInAsUser();
   ash::DisplayLayout layout(ash::DisplayLayout::TOP, 10);
   SetCurrentDisplayLayout(layout);
   StoreDisplayLayoutPrefForTest(
@@ skipping 27 matching lines @@
       local_state()->GetDictionary(prefs::kDisplayProperties);
   const base::DictionaryValue* property = NULL;
   EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id1), &property));
   int ui_scale = 0;
   int rotation = 0;
   EXPECT_TRUE(property->GetInteger("rotation", &rotation));
   EXPECT_TRUE(property->GetInteger("ui-scale", &ui_scale));
   EXPECT_EQ(1, rotation);
   EXPECT_EQ(1250, ui_scale);
 
+  // Internal display never registere the resolution.
+  int width = 0, height = 0;
+  EXPECT_FALSE(property->GetInteger("width", &width));
+  EXPECT_FALSE(property->GetInteger("height", &height));
+
   int top = 0, left = 0, bottom = 0, right = 0;
   EXPECT_TRUE(property->GetInteger("insets_top", &top));
   EXPECT_TRUE(property->GetInteger("insets_left", &left));
   EXPECT_TRUE(property->GetInteger("insets_bottom", &bottom));
   EXPECT_TRUE(property->GetInteger("insets_right", &right));
   EXPECT_EQ(10, top);
   EXPECT_EQ(11, left);
   EXPECT_EQ(12, bottom);
   EXPECT_EQ(13, right);
 
   EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id2), &property));
   EXPECT_TRUE(property->GetInteger("rotation", &rotation));
   EXPECT_TRUE(property->GetInteger("ui-scale", &ui_scale));
   EXPECT_EQ(0, rotation);
   // ui_scale works only on 2x scale factor/1st display.
   EXPECT_EQ(1000, ui_scale);
   EXPECT_FALSE(property->GetInteger("insets_top", &top));
   EXPECT_FALSE(property->GetInteger("insets_left", &left));
   EXPECT_FALSE(property->GetInteger("insets_bottom", &bottom));
   EXPECT_FALSE(property->GetInteger("insets_right", &right));
 
+  // Resolution is saved only when the resolution is set
+  // by DisplayManager::SetDisplayResolution
+  width = 0;
+  height = 0;
+  EXPECT_FALSE(property->GetInteger("width", &width));
+  EXPECT_FALSE(property->GetInteger("height", &height));
+
+  display_manager->SetDisplayResolution(id2, gfx::Size(400, 300));
+
   display_controller->SetPrimaryDisplayId(id2);
 
+  EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id1), &property));
+  width = 0;
+  height = 0;
+  // Internal dispaly shouldn't store its resolution.
+  EXPECT_FALSE(property->GetInteger("width", &width));
+  EXPECT_FALSE(property->GetInteger("height", &height));
+
+  // External dispaly's resolution must be stored this time.
+  EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id2), &property));
+  EXPECT_TRUE(property->GetInteger("width", &width));
+  EXPECT_TRUE(property->GetInteger("height", &height));
+  EXPECT_EQ(400, width);
+  EXPECT_EQ(300, height);
+
   // The layout remains the same.
   EXPECT_TRUE(displays->GetDictionary(key, &layout_value));
   EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*layout_value,
                                                    &stored_layout));
   EXPECT_EQ(layout.position, stored_layout.position);
   EXPECT_EQ(layout.offset, stored_layout.offset);
   EXPECT_EQ(id2, stored_layout.primary_id);
 
   mirrored = true;
   EXPECT_TRUE(layout_value->GetBoolean(kMirroredKey, &mirrored));
@@ skipping 13 matching lines @@
   EXPECT_TRUE(layout_value->GetString(kPositionKey, &position));
   EXPECT_EQ("top", position);
   EXPECT_TRUE(layout_value->GetInteger(kOffsetKey, &offset));
   EXPECT_EQ(-20, offset);
   mirrored = false;
   EXPECT_TRUE(layout_value->GetBoolean(kMirroredKey, &mirrored));
   EXPECT_TRUE(mirrored);
   EXPECT_TRUE(layout_value->GetString(kPrimaryIdKey, &primary_id_str));
   EXPECT_EQ(base::Int64ToString(id2), primary_id_str);
 
-  UpdateDisplay("200x200*2,200x200");
+  EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id1), &property));
+  EXPECT_FALSE(property->GetInteger("width", &width));
+  EXPECT_FALSE(property->GetInteger("height", &height));
+
+  // External dispaly's selected resolution must not change
+  // by mirroring.
+  EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id2), &property));
+  EXPECT_TRUE(property->GetInteger("width", &width));
+  EXPECT_TRUE(property->GetInteger("height", &height));
+  EXPECT_EQ(400, width);
+  EXPECT_EQ(300, height);
+
+  // Set new display's selected resolution.
+  display_manager->SetDisplayResolution(id2 + 1, gfx::Size(500, 400));
+  UpdateDisplay("200x200*2,500x400");
   // Update key as the 2nd display gets new id.
   id2 = ash::ScreenAsh::GetSecondaryDisplay().id();
   key = base::Int64ToString(id1) + "," + base::Int64ToString(id2);
   EXPECT_TRUE(displays->GetDictionary(key, &layout_value));
   EXPECT_TRUE(layout_value->GetString(kPositionKey, &position));
   EXPECT_EQ("right", position);
   EXPECT_TRUE(layout_value->GetInteger(kOffsetKey, &offset));
   EXPECT_EQ(0, offset);
   mirrored = true;
   EXPECT_TRUE(layout_value->GetBoolean(kMirroredKey, &mirrored));
   EXPECT_FALSE(mirrored);
   EXPECT_TRUE(layout_value->GetString(kPrimaryIdKey, &primary_id_str));
   EXPECT_EQ(base::Int64ToString(id1), primary_id_str);
+
+  // External dispaly's selected resolution must be updated.
+  EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id2), &property));
+  EXPECT_TRUE(property->GetInteger("width", &width));
+  EXPECT_TRUE(property->GetInteger("height", &height));
+  EXPECT_EQ(500, width);
+  EXPECT_EQ(400, height);
 }
 
 TEST_F(DisplayPreferencesTest, StoreForSwappedDisplay) {
   UpdateDisplay("100x100,200x200");
   int64 id1 = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id();
   int64 id2 = ash::ScreenAsh::GetSecondaryDisplay().id();
 
   ash::DisplayController* display_controller =
       ash::Shell::GetInstance()->display_controller();
   display_controller->SwapPrimaryDisplay();
@@ skipping 77 matching lines @@
   StoreDisplayPowerStateForTest(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON);
   LoadDisplayPreferences(false);
   EXPECT_EQ(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
       ash::Shell::GetInstance()->output_configurator()->power_state());
 }
 
 }  // namespace
 }  // namespace chromeos