Added a timezone policy and pyauto tests for it.

chrome/browser/policy/browser_policy_connector.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/policy/browser_policy_connector.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 28 matching lines @@
 #if defined(OS_WIN)
 #include "chrome/browser/policy/policy_loader_win.h"
 #elif defined(OS_MACOSX)
 #include "chrome/browser/policy/policy_loader_mac.h"
 #include "chrome/browser/preferences_mac.h"
 #elif defined(OS_POSIX)
 #include "chrome/browser/policy/config_dir_policy_loader.h"
 #endif
 
 #if defined(OS_CHROMEOS)
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/login/authenticator.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/chromeos/settings/cros_settings_provider.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
+#include "chrome/browser/chromeos/system/timezone_settings.h"
 #include "chrome/browser/policy/app_pack_updater.h"
 #include "chrome/browser/policy/cros_user_policy_cache.h"
 #include "chrome/browser/policy/device_policy_cache.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #endif
 
 using content::BrowserThread;
 
 namespace policy {
 
@@ skipping 87 matching lines @@
     managed_cloud_provider_.reset(new CloudPolicyProvider(
         this,
         POLICY_LEVEL_MANDATORY));
     recommended_cloud_provider_.reset(new CloudPolicyProvider(
         this,
         POLICY_LEVEL_RECOMMENDED));
   }
 
   InitializeDevicePolicy();
 
-  // Create the AppPackUpdater to start updating the cache. It requires the
-  // system request context, which isn't available yet; therefore it is
-  // created only once the loops are running.
+  // Complete the initialization once the message loops are spinning.
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(base::IgnoreResult(&BrowserPolicyConnector::GetAppPackUpdater),
+      base::Bind(&BrowserPolicyConnector::CompleteInitialization,
                  weak_ptr_factory_.GetWeakPtr()));
 #endif
 }
 
 scoped_ptr<UserCloudPolicyManager>
     BrowserPolicyConnector::CreateCloudPolicyManager(Profile* profile) {
   scoped_ptr<UserCloudPolicyManager> manager;
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kEnableCloudPolicyService)) {
     bool wait_for_policy_fetch = false;
@@ skipping 366 matching lines @@
           new DevicePolicyCache(device_data_store_.get(),
                                 install_attributes_.get());
 
       managed_cloud_provider_->SetDevicePolicyCache(device_policy_cache);
       recommended_cloud_provider_->SetDevicePolicyCache(device_policy_cache);
 
       device_cloud_policy_subsystem_.reset(new CloudPolicySubsystem(
           device_data_store_.get(),
           device_policy_cache,
           GetDeviceManagementUrl()));
-
-      // Initialize the subsystem once the message loops are spinning.
-      MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(&BrowserPolicyConnector::CompleteInitialization,
-                     weak_ptr_factory_.GetWeakPtr()));
     }
   }
 #endif
 }
 
 void BrowserPolicyConnector::CompleteInitialization() {
 #if defined(OS_CHROMEOS)
+
+  // Create the AppPackUpdater to start updating the cache. It requires the
+  // system request context, which isn't available in Init(); therefore it is
+  // created only once the loops are running.
+  GetAppPackUpdater();
+
   if (device_cloud_policy_subsystem_.get()) {
     // Read serial number and machine model. This must be done before we call
     // CompleteInitialization() below such that the serial number is available
     // for re-submission in case we're doing serial number recovery.
     if (device_data_store_->machine_id().empty() ||
         device_data_store_->machine_model().empty()) {
       chromeos::system::StatisticsProvider* provider =
           chromeos::system::StatisticsProvider::GetInstance();
 
       std::string machine_model;
       if (!provider->GetMachineStatistic(kMachineInfoSystemHwqual,
                                          &machine_model)) {
         LOG(ERROR) << "Failed to get machine model.";
       }
 
       std::string machine_id = GetSerialNumber();
       if (machine_id.empty())
         LOG(ERROR) << "Failed to get machine serial number.";
 
       device_data_store_->set_machine_id(machine_id);
       device_data_store_->set_machine_model(machine_model);
     }
 
     device_cloud_policy_subsystem_->CompleteInitialization(
         prefs::kDevicePolicyRefreshRate,
         kServiceInitializationStartupDelay);
   }
-  device_data_store_->set_device_status_collector(
-      new DeviceStatusCollector(
-          g_browser_process->local_state(),
-          chromeos::system::StatisticsProvider::GetInstance(),
-          NULL));
+
+  if (device_data_store_.get()) {
+    device_data_store_->set_device_status_collector(
+        new DeviceStatusCollector(
+            g_browser_process->local_state(),
+            chromeos::system::StatisticsProvider::GetInstance(),
+            NULL));
+  }
+
+  SetTimezoneIfPolicyAvailable();
 #endif
 }
 
+void BrowserPolicyConnector::SetTimezoneIfPolicyAvailable() {
+#if defined(OS_CHROMEOS)
+  typedef chromeos::CrosSettingsProvider Provider;
+  Provider::TrustedStatus result =
+      chromeos::CrosSettings::Get()->PrepareTrustedValues(
+          base::Bind(&BrowserPolicyConnector::SetTimezoneIfPolicyAvailable,
+                     weak_ptr_factory_.GetWeakPtr()));
+
+  if (result != Provider::TRUSTED)
+    return;
+
+  std::string timezone;
+  if (chromeos::CrosSettings::Get()->GetString(
+          chromeos::kSystemTimezonePolicy, &timezone)) {
+    chromeos::system::TimezoneSettings::GetInstance()->SetTimezoneFromID(
+        UTF8ToUTF16(timezone));
+  }
+#endif
+}
+
 // static
 ConfigurationPolicyProvider* BrowserPolicyConnector::CreatePlatformProvider() {
 #if defined(OS_WIN)
   const PolicyDefinitionList* policy_list = GetChromePolicyDefinitionList();
   scoped_ptr<AsyncPolicyLoader> loader(new PolicyLoaderWin(policy_list));
   return new AsyncPolicyProvider(loader.Pass());
 #elif defined(OS_MACOSX)
   const PolicyDefinitionList* policy_list = GetChromePolicyDefinitionList();
   scoped_ptr<AsyncPolicyLoader> loader(
       new PolicyLoaderMac(policy_list, new MacPreferences()));
   return new AsyncPolicyProvider(loader.Pass());
 #elif defined(OS_POSIX)
   FilePath config_dir_path;
   if (PathService::Get(chrome::DIR_POLICY_FILES, &config_dir_path)) {
     scoped_ptr<AsyncPolicyLoader> loader(
         new ConfigDirPolicyLoader(config_dir_path, POLICY_SCOPE_MACHINE));
     return new AsyncPolicyProvider(loader.Pass());
   } else {
     return NULL;
   }
 #else
   return NULL;
 #endif
 }
 
 }  // namespace policy