chrome/browser/prefs/pref_service_browsertest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "base/command_line.h"
   8 #include "base/files/file_util.h"
   9 #include "base/files/scoped_temp_dir.h"
  10 #include "base/json/json_file_value_serializer.h"
  11 #include "base/path_service.h"
  12 #include "base/test/test_file_util.h"
  13 #include "base/values.h"
  14 #include "build/build_config.h"
  15 #include "chrome/browser/ui/browser.h"
  16 #include "chrome/browser/ui/browser_window.h"
  17 #include "chrome/browser/ui/browser_window_state.h"
  18 #include "chrome/common/chrome_constants.h"
  19 #include "chrome/common/chrome_paths.h"
  20 #include "chrome/common/pref_names.h"
  21 #include "chrome/test/base/in_process_browser_test.h"
  22 #include "chrome/test/base/test_switches.h"
  23 #include "chrome/test/base/testing_profile.h"
  24 #include "chrome/test/base/ui_test_utils.h"
  25 #include "ui/gfx/rect.h"
  26
  27 typedef InProcessBrowserTest PreservedWindowPlacement;
  28
  29 IN_PROC_BROWSER_TEST_F(PreservedWindowPlacement, PRE_Test) {
  30   browser()->window()->SetBounds(gfx::Rect(20, 30, 400, 500));
  31 }
  32
  33 // Fails on Chrome OS as the browser thinks it is restarting after a crash, see
  34 // http://crbug.com/168044
  35 #if defined(OS_CHROMEOS)
  36 #define MAYBE_Test DISABLED_Test
  37 #else
  38 #define MAYBE_Test Test
  39 #endif
  40 IN_PROC_BROWSER_TEST_F(PreservedWindowPlacement, MAYBE_Test) {
  41 #if defined(OS_WIN) && defined(USE_ASH)
  42   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
  43   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
  44     return;
  45 #endif
  46
  47   gfx::Rect bounds = browser()->window()->GetBounds();
  48   gfx::Rect expected_bounds(gfx::Rect(20, 30, 400, 500));
  49   ASSERT_EQ(expected_bounds.ToString(), bounds.ToString());
  50 }
  51
  52 class PreferenceServiceTest : public InProcessBrowserTest {
  53  public:
  54   explicit PreferenceServiceTest(bool new_profile) : new_profile_(new_profile) {
  55   }
  56
  57   virtual bool SetUpUserDataDirectory() OVERRIDE {
  58     base::FilePath user_data_directory;
  59     PathService::Get(chrome::DIR_USER_DATA, &user_data_directory);
  60
  61     if (new_profile_) {
  62       original_pref_file_ = ui_test_utils::GetTestFilePath(
  63           base::FilePath().AppendASCII("profiles").
  64                      AppendASCII("window_placement").
  65                      AppendASCII("Default"),
  66           base::FilePath().Append(chrome::kPreferencesFilename));
  67       tmp_pref_file_ =
  68           user_data_directory.AppendASCII(TestingProfile::kTestUserProfileDir);
  69       CHECK(base::CreateDirectory(tmp_pref_file_));
  70       tmp_pref_file_ = tmp_pref_file_.Append(chrome::kPreferencesFilename);
  71     } else {
  72       original_pref_file_ = ui_test_utils::GetTestFilePath(
  73           base::FilePath().AppendASCII("profiles").
  74                      AppendASCII("window_placement"),
  75           base::FilePath().Append(chrome::kLocalStateFilename));
  76       tmp_pref_file_ = user_data_directory.Append(chrome::kLocalStateFilename);
  77     }
  78
  79     CHECK(base::PathExists(original_pref_file_));
  80     // Copy only the Preferences file if |new_profile_|, or Local State if not,
  81     // and the rest will be automatically created.
  82     CHECK(base::CopyFile(original_pref_file_, tmp_pref_file_));
  83
  84 #if defined(OS_WIN)
  85     // Make the copy writable.  On POSIX we assume the umask allows files
  86     // we create to be writable.
  87     CHECK(::SetFileAttributesW(tmp_pref_file_.value().c_str(),
  88         FILE_ATTRIBUTE_NORMAL));
  89 #endif
  90     return true;
  91   }
  92
  93  protected:
  94   base::FilePath original_pref_file_;
  95   base::FilePath tmp_pref_file_;
  96
  97  private:
  98   bool new_profile_;
  99 };
 100
 101 #if defined(OS_WIN) || defined(OS_MACOSX)
 102 // This test verifies that the window position from the prefs file is restored
 103 // when the app restores.  This doesn't really make sense on Linux, where
 104 // the window manager might fight with you over positioning.  However, we
 105 // might be able to make this work on buildbots.
 106 // TODO(port): revisit this.
 107
 108 class PreservedWindowPlacementIsLoaded : public PreferenceServiceTest {
 109  public:
 110   PreservedWindowPlacementIsLoaded() : PreferenceServiceTest(true) {
 111   }
 112 };
 113
 114 IN_PROC_BROWSER_TEST_F(PreservedWindowPlacementIsLoaded, Test) {
 115 #if defined(OS_WIN) && defined(USE_ASH)
 116   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 117   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 118     return;
 119 #endif
 120
 121   // The window should open with the new reference profile, with window
 122   // placement values stored in the user data directory.
 123   JSONFileValueSerializer deserializer(original_pref_file_);
 124   scoped_ptr<base::Value> root(deserializer.Deserialize(NULL, NULL));
 125
 126   ASSERT_TRUE(root.get());
 127   ASSERT_TRUE(root->IsType(base::Value::TYPE_DICTIONARY));
 128
 129   base::DictionaryValue* root_dict =
 130       static_cast<base::DictionaryValue*>(root.get());
 131
 132   // Retrieve the screen rect for the launched window
 133   gfx::Rect bounds = browser()->window()->GetRestoredBounds();
 134
 135   // Retrieve the expected rect values from "Preferences"
 136   int bottom = 0;
 137   std::string kBrowserWindowPlacement(prefs::kBrowserWindowPlacement);
 138   EXPECT_TRUE(root_dict->GetInteger(kBrowserWindowPlacement + ".bottom",
 139       &bottom));
 140   EXPECT_EQ(bottom, bounds.y() + bounds.height());
 141
 142   int top = 0;
 143   EXPECT_TRUE(root_dict->GetInteger(kBrowserWindowPlacement + ".top",
 144       &top));
 145   EXPECT_EQ(top, bounds.y());
 146
 147   int left = 0;
 148   EXPECT_TRUE(root_dict->GetInteger(kBrowserWindowPlacement + ".left",
 149       &left));
 150   EXPECT_EQ(left, bounds.x());
 151
 152   int right = 0;
 153   EXPECT_TRUE(root_dict->GetInteger(kBrowserWindowPlacement + ".right",
 154       &right));
 155   EXPECT_EQ(right, bounds.x() + bounds.width());
 156
 157   // Find if launched window is maximized.
 158   bool is_window_maximized = browser()->window()->IsMaximized();
 159   bool is_maximized = false;
 160   EXPECT_TRUE(root_dict->GetBoolean(kBrowserWindowPlacement + ".maximized",
 161       &is_maximized));
 162   EXPECT_EQ(is_maximized, is_window_maximized);
 163 }
 164 #endif
 165
 166 #if defined(OS_WIN) || defined(OS_MACOSX)
 167
 168 class PreservedWindowPlacementIsMigrated : public PreferenceServiceTest {
 169  public:
 170   PreservedWindowPlacementIsMigrated() : PreferenceServiceTest(false) {
 171   }
 172 };
 173
 174 IN_PROC_BROWSER_TEST_F(PreservedWindowPlacementIsMigrated, Test) {
 175 #if defined(OS_WIN) && defined(USE_ASH)
 176   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 177   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 178     return;
 179 #endif
 180
 181   // The window should open with the old reference profile, with window
 182   // placement values stored in Local State.
 183
 184   JSONFileValueSerializer deserializer(original_pref_file_);
 185   scoped_ptr<base::Value> root(deserializer.Deserialize(NULL, NULL));
 186
 187   ASSERT_TRUE(root.get());
 188   ASSERT_TRUE(root->IsType(base::Value::TYPE_DICTIONARY));
 189
 190   // Retrieve the screen rect for the launched window
 191   gfx::Rect bounds = browser()->window()->GetRestoredBounds();
 192
 193   // Values from old reference profile in Local State should have been
 194   // correctly migrated to the user's Preferences -- if so, the window
 195   // should be set to values taken from the user's Local State.
 196   base::DictionaryValue* root_dict =
 197       static_cast<base::DictionaryValue*>(root.get());
 198
 199   // Retrieve the expected rect values from User Preferences, where they
 200   // should have been migrated from Local State.
 201   int bottom = 0;
 202   std::string kBrowserWindowPlacement(prefs::kBrowserWindowPlacement);
 203   EXPECT_TRUE(root_dict->GetInteger(kBrowserWindowPlacement + ".bottom",
 204       &bottom));
 205   EXPECT_EQ(bottom, bounds.y() + bounds.height());
 206
 207   int top = 0;
 208   EXPECT_TRUE(root_dict->GetInteger(kBrowserWindowPlacement + ".top",
 209       &top));
 210   EXPECT_EQ(top, bounds.y());
 211
 212   int left = 0;
 213   EXPECT_TRUE(root_dict->GetInteger(kBrowserWindowPlacement + ".left",
 214       &left));
 215   EXPECT_EQ(left, bounds.x());
 216
 217   int right = 0;
 218   EXPECT_TRUE(root_dict->GetInteger(kBrowserWindowPlacement + ".right",
 219       &right));
 220   EXPECT_EQ(right, bounds.x() + bounds.width());
 221
 222   // Find if launched window is maximized.
 223   bool is_window_maximized = browser()->window()->IsMaximized();
 224   bool is_maximized = false;
 225   EXPECT_TRUE(root_dict->GetBoolean(kBrowserWindowPlacement + ".maximized",
 226       &is_maximized));
 227   EXPECT_EQ(is_maximized, is_window_maximized);
 228 }
 229 #endif