text: // 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/display/resolution_notification_controller.h"
  #include "ash/screen_ash.h"
  #include "ash/shell.h"
  #include "ash/test/ash_test_base.h"
  #include "base/prefs/testing_pref_service.h"
  #include "base/strings/string_number_conversions.h"
  #include "base/values.h"
  #include "chrome/browser/chromeos/display/display_configuration_observer.h"
  #include "chrome/browser/chromeos/login/mock_user_manager.h"
  #include "chrome/browser/chromeos/login/user_manager.h"
  #include "chrome/browser/prefs/scoped_user_pref_update.h"
  #include "chrome/common/pref_names.h"
  #include "chrome/test/base/testing_browser_process.h"
  #include "chromeos/display/output_configurator.h"
  #include "ui/message_center/message_center.h"
  
  using ash::internal::ResolutionNotificationController;
  
  namespace chromeos {
  namespace {
  const char kPrimaryIdKey[] = "primary-id";
  const char kMirroredKey[] = "mirrored";
  const char kPositionKey[] = "position";
  const char kOffsetKey[] = "offset";
  
  class DisplayPreferencesTest : public ash::test::AshTestBase {
   protected:
    DisplayPreferencesTest() : ash::test::AshTestBase(),
                               mock_user_manager_(new MockUserManager),
                               user_manager_enabler_(mock_user_manager_) {
    }
  
    virtual ~DisplayPreferencesTest() {}
  
    virtual void SetUp() OVERRIDE {
      EXPECT_CALL(*mock_user_manager_, IsUserLoggedIn())
          .WillRepeatedly(testing::Return(false));
      EXPECT_CALL(*mock_user_manager_, Shutdown());
      ash::test::AshTestBase::SetUp();
      RegisterDisplayLocalStatePrefs(local_state_.registry());
      TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_);
      observer_.reset(new DisplayConfigurationObserver());
    }
  
    virtual void TearDown() OVERRIDE {
      observer_.reset();
      TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
      ash::test::AshTestBase::TearDown();
    }
  
    void LoggedInAsUser() {
      EXPECT_CALL(*mock_user_manager_, IsUserLoggedIn())
          .WillRepeatedly(testing::Return(true));
      EXPECT_CALL(*mock_user_manager_, IsLoggedInAsRegularUser())
          .WillRepeatedly(testing::Return(true));
    }
  
    void LoggedInAsGuest() {
      EXPECT_CALL(*mock_user_manager_, IsUserLoggedIn())
          .WillRepeatedly(testing::Return(true));
      EXPECT_CALL(*mock_user_manager_, IsLoggedInAsRegularUser())
          .WillRepeatedly(testing::Return(false));
      EXPECT_CALL(*mock_user_manager_, IsLoggedInAsLocallyManagedUser())
          .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,
                                       ash::DisplayLayout::Position layout,
                                       int offset,
                                       int64 primary_id) {
      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,
                                       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);
    }
  
    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());
      insets_value->SetInteger("insets_bottom", insets.bottom());
      insets_value->SetInteger("insets_right", insets.right());
      pref_data->Set(name, insets_value);
    }
  
    std::string GetRegisteredDisplayLayoutStr(int64 id1, int64 id2) {
      ash::DisplayIdPair pair;
      pair.first = id1;
      pair.second = id2;
      return ash::Shell::GetInstance()->display_manager()->layout_store()->
          GetRegisteredDisplayLayout(pair).ToString();
    }
  
    const PrefService* local_state() const { 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::ScreenAsh::GetSecondaryDisplay().id();
    int64 dummy_id = id2 + 1;
    ASSERT_NE(id1, dummy_id);
  
    StoreDisplayLayoutPrefForPair(id1, id2, ash::DisplayLayout::TOP, 20);
    StoreDisplayLayoutPrefForPair(id1, dummy_id, 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->output_configurator()->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));
  }
  
  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, 400x300#400x400|300x200");
    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(
        id1, dummy_id, ash::DisplayLayout(ash::DisplayLayout::LEFT, 20));
    // Can't switch to a display that does not exist.
    display_controller->SetPrimaryDisplayId(dummy_id);
    EXPECT_NE(dummy_id, display_controller->GetPrimaryDisplay().id());
  
    display_controller->SetOverscanInsets(id1, gfx::Insets(10, 11, 12, 13));
    display_manager->SetDisplayRotation(id1, gfx::Display::ROTATE_90);
    display_manager->SetDisplayUIScale(id1, 1.25f);
    display_manager->SetDisplayUIScale(id2, 1.25f);
  
    const base::DictionaryValue* displays =
        local_state()->GetDictionary(prefs::kSecondaryDisplays);
    const base::DictionaryValue* layout_value = NULL;
    std::string key = base::Int64ToString(id1) + "," + base::Int64ToString(id2);
    EXPECT_TRUE(displays->GetDictionary(key, &layout_value));
  
    ash::DisplayLayout stored_layout;
    EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*layout_value,
                                                     &stored_layout));
    EXPECT_EQ(layout.position, stored_layout.position);
    EXPECT_EQ(layout.offset, stored_layout.offset);
  
    bool mirrored = true;
    EXPECT_TRUE(layout_value->GetBoolean(kMirroredKey, &mirrored));
    EXPECT_FALSE(mirrored);
  
    const base::DictionaryValue* properties =
        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(300, 200));
  
    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 because
    // it's not best.
    EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id2), &property));
    EXPECT_TRUE(property->GetInteger("width", &width));
    EXPECT_TRUE(property->GetInteger("height", &height));
    EXPECT_EQ(300, width);
    EXPECT_EQ(200, 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));
    EXPECT_FALSE(mirrored);
    std::string primary_id_str;
    EXPECT_TRUE(layout_value->GetString(kPrimaryIdKey, &primary_id_str));
    EXPECT_EQ(base::Int64ToString(id2), primary_id_str);
  
    SetCurrentDisplayLayout(
        ash::DisplayLayout(ash::DisplayLayout::BOTTOM, 20));
  
    UpdateDisplay("1+0-200x200*2,1+0-200x200");
    // Mirrored.
    int offset = 0;
    std::string position;
    EXPECT_TRUE(displays->GetDictionary(key, &layout_value));
    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);
  
    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(300, width);
    EXPECT_EQ(200, height);
  
    // Set new display's selected resolution.
    display_manager->RegisterDisplayProperty(id2 + 1,
                                             gfx::Display::ROTATE_0,
                                             1.0f,
                                             NULL,
                                             gfx::Size(500, 400));
  
    UpdateDisplay("200x200*2, 600x500#600x500|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, PreventStore) {
    ResolutionNotificationController::SuppressTimerForTest();
    LoggedInAsUser();
    UpdateDisplay("400x300#500x400|400x300|300x200");
    int64 id = ash::Shell::GetScreen()->GetPrimaryDisplay().id();
    // Set display's resolution in single display. It creates the notification and
    // display preferences should not stored meanwhile.
    ash::Shell::GetInstance()->resolution_notification_controller()->
        SetDisplayResolutionAndNotify(
            id, gfx::Size(400, 300), gfx::Size(500, 400), base::Closure());
    UpdateDisplay("500x400#500x400|400x300|300x200");
  
    const base::DictionaryValue* properties =
        local_state()->GetDictionary(prefs::kDisplayProperties);
    const base::DictionaryValue* property = NULL;
    EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id), &property));
    int width = 0, height = 0;
    EXPECT_FALSE(property->GetInteger("width", &width));
    EXPECT_FALSE(property->GetInteger("height", &height));
  
    // Revert the change. When timeout, 2nd button is revert.
    message_center::MessageCenter::Get()->ClickOnNotificationButton(
        ResolutionNotificationController::kNotificationId, 1);
    RunAllPendingInMessageLoop();
    EXPECT_FALSE(message_center::MessageCenter::Get()->HasNotification(
        ResolutionNotificationController::kNotificationId));
  
    // Once the notification is removed, the specified resolution will be stored
    // by SetDisplayResolution.
    ash::Shell::GetInstance()->display_manager()->SetDisplayResolution(
        id, gfx::Size(300, 200));
    UpdateDisplay("300x200#500x400|400x300|300x200");
  
    property = NULL;
    EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id), &property));
    EXPECT_TRUE(property->GetInteger("width", &width));
    EXPECT_TRUE(property->GetInteger("height", &height));
    EXPECT_EQ(300, width);
    EXPECT_EQ(200, 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();
    ASSERT_EQ(id1, ash::ScreenAsh::GetSecondaryDisplay().id());
  
    LoggedInAsUser();
    ash::DisplayLayout layout(ash::DisplayLayout::TOP, 10);
    SetCurrentDisplayLayout(layout);
    layout = layout.Invert();
  
    const base::DictionaryValue* displays =
        local_state()->GetDictionary(prefs::kSecondaryDisplays);
    const base::DictionaryValue* new_value = NULL;
    std::string key = base::Int64ToString(id1) + "," + base::Int64ToString(id2);
    EXPECT_TRUE(displays->GetDictionary(key, &new_value));
  
    ash::DisplayLayout stored_layout;
    EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
    EXPECT_EQ(layout.position, stored_layout.position);
    EXPECT_EQ(layout.offset, stored_layout.offset);
    EXPECT_EQ(id2, stored_layout.primary_id);
  
    display_controller->SwapPrimaryDisplay();
    EXPECT_TRUE(displays->GetDictionary(key, &new_value));
    EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
    EXPECT_EQ(layout.position, stored_layout.position);
    EXPECT_EQ(layout.offset, stored_layout.offset);
    EXPECT_EQ(id1, stored_layout.primary_id);
  }
  
  TEST_F(DisplayPreferencesTest, DontStoreInGuestMode) {
    ash::DisplayController* display_controller =
        ash::Shell::GetInstance()->display_controller();
    ash::internal::DisplayManager* display_manager =
        ash::Shell::GetInstance()->display_manager();
  
    UpdateDisplay("200x200*2,200x200");
  
    LoggedInAsGuest();
    int64 id1 = ash::ScreenAsh::GetNativeScreen()->GetPrimaryDisplay().id();
    gfx::Display::SetInternalDisplayId(id1);
    int64 id2 = ash::ScreenAsh::GetSecondaryDisplay().id();
    ash::DisplayLayout layout(ash::DisplayLayout::TOP, 10);
    SetCurrentDisplayLayout(layout);
    display_manager->SetDisplayUIScale(id1, 1.25f);
    display_controller->SetPrimaryDisplayId(id2);
    int64 new_primary =
        ash::ScreenAsh::GetNativeScreen()->GetPrimaryDisplay().id();
    display_controller->SetOverscanInsets(
        new_primary,
        gfx::Insets(10, 11, 12, 13));
    display_manager->SetDisplayRotation(new_primary, gfx::Display::ROTATE_90);
  
    // Does not store the preferences locally.
    EXPECT_FALSE(local_state()->FindPreference(
        prefs::kSecondaryDisplays)->HasUserSetting());
    EXPECT_FALSE(local_state()->FindPreference(
        prefs::kDisplayProperties)->HasUserSetting());
  
    // Settings are still notified to the system.
    gfx::Screen* screen = gfx::Screen::GetNativeScreen();
    EXPECT_EQ(id2, screen->GetPrimaryDisplay().id());
    EXPECT_EQ(ash::DisplayLayout::BOTTOM,
              display_manager->GetCurrentDisplayLayout().position);
    EXPECT_EQ(-10, display_manager->GetCurrentDisplayLayout().offset);
    const gfx::Display& primary_display = screen->GetPrimaryDisplay();
    EXPECT_EQ("178x176", primary_display.bounds().size().ToString());
    EXPECT_EQ(gfx::Display::ROTATE_90, primary_display.rotation());
  
    const ash::internal::DisplayInfo& info1 =
        display_manager->GetDisplayInfo(id1);
    EXPECT_EQ(1.25f, info1.ui_scale());
  
    const ash::internal::DisplayInfo& info_primary =
        display_manager->GetDisplayInfo(new_primary);
    EXPECT_EQ(gfx::Display::ROTATE_90, info_primary.rotation());
    EXPECT_EQ(1.0f, info_primary.ui_scale());
  }
  
  TEST_F(DisplayPreferencesTest, StorePowerStateNoLogin) {
    EXPECT_FALSE(local_state()->HasPrefPath(prefs::kDisplayPowerState));
  
    // Stores display prefs without login, which still stores the power state.
    StoreDisplayPrefs();
    EXPECT_TRUE(local_state()->HasPrefPath(prefs::kDisplayPowerState));
  }
  
  TEST_F(DisplayPreferencesTest, StorePowerStateGuest) {
    EXPECT_FALSE(local_state()->HasPrefPath(prefs::kDisplayPowerState));
  
    LoggedInAsGuest();
    StoreDisplayPrefs();
    EXPECT_TRUE(local_state()->HasPrefPath(prefs::kDisplayPowerState));
  }
  
  TEST_F(DisplayPreferencesTest, StorePowerStateNormalUser) {
    EXPECT_FALSE(local_state()->HasPrefPath(prefs::kDisplayPowerState));
  
    LoggedInAsUser();
    StoreDisplayPrefs();
    EXPECT_TRUE(local_state()->HasPrefPath(prefs::kDisplayPowerState));
  }
  
  TEST_F(DisplayPreferencesTest, DisplayPowerStateAfterRestart) {
    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 chromeos
  