Update server-backed state key generation.

chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos_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/policy/device_cloud_policy_manager_chromeos.h"
 
+#include <algorithm>
+
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/policy/enterprise_install_attributes.h"
 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
@@ skipping 237 matching lines @@
 
   manager_->Connect(&local_state_,
                     &device_management_service_,
                     scoped_ptr<CloudPolicyClient::StatusProvider>());
   EXPECT_TRUE(manager_->policies().Equals(bundle));
 
   manager_->Shutdown();
   EXPECT_TRUE(manager_->policies().Equals(bundle));
 }
 
+class DeviceCloudPolicyManagerChromeOSStateKeyTest : public testing::Test {
+ protected:
+  DeviceCloudPolicyManagerChromeOSStateKeyTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    chromeos::system::StatisticsProvider::SetTestProvider(
+        &statistics_provider_);
+    EXPECT_CALL(statistics_provider_, GetMachineStatistic(_, _))
+        .WillRepeatedly(Invoke(this,
+                               &DeviceCloudPolicyManagerChromeOSStateKeyTest::
+                                   GetMachineStatistic));
+  }
+
+  virtual void TearDown() OVERRIDE {
+    chromeos::system::StatisticsProvider::SetTestProvider(NULL);
+  }
+
+  bool GetMachineStatistic(const std::string& name, std::string* result) {
+    *result = "fake-" + name;
+    return true;
+  }
+
+ private:
+  chromeos::system::MockStatisticsProvider statistics_provider_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceCloudPolicyManagerChromeOSStateKeyTest);
+};
+
+TEST_F(DeviceCloudPolicyManagerChromeOSStateKeyTest, GetDeviceStateKeys) {
+  base::Time current = base::Time::UnixEpoch() + base::TimeDelta::FromDays(100);
+
+  // The correct number of state keys gets returned.
+  std::vector<std::string> state_keys;
+  EXPECT_TRUE(DeviceCloudPolicyManagerChromeOS::GetDeviceStateKeys(
+      current, &state_keys));
+  EXPECT_EQ(DeviceCloudPolicyManagerChromeOS::kDeviceStateKeyFutureQuanta,
+            static_cast<int>(state_keys.size()));
+
+  // All state keys are different.
+  std::set<std::string> state_key_set(state_keys.begin(), state_keys.end());
+  EXPECT_EQ(DeviceCloudPolicyManagerChromeOS::kDeviceStateKeyFutureQuanta,
+            static_cast<int>(state_key_set.size()));
+
+  // Moving forward just a little yields the same keys.
+  std::vector<std::string> new_state_keys;
+  current += base::TimeDelta::FromDays(1);
+  EXPECT_TRUE(DeviceCloudPolicyManagerChromeOS::GetDeviceStateKeys(
+      current, &new_state_keys));
+  EXPECT_EQ(state_keys, new_state_keys);
+
+  // Jumping to a future quantum results in the state keys rolling forward.
+  int64 step =
+      GG_INT64_C(1)
+      << DeviceCloudPolicyManagerChromeOS::kDeviceStateKeyTimeQuantumPower;
+  current += 2 * base::TimeDelta::FromSeconds(step);
+
+  EXPECT_TRUE(DeviceCloudPolicyManagerChromeOS::GetDeviceStateKeys(
+      current, &new_state_keys));
+  ASSERT_EQ(DeviceCloudPolicyManagerChromeOS::kDeviceStateKeyFutureQuanta,
+            static_cast<int>(new_state_keys.size()));
+  EXPECT_TRUE(std::equal(state_keys.begin() + 2, state_keys.end(),
+                         new_state_keys.begin()));
+}
+
 class DeviceCloudPolicyManagerChromeOSEnrollmentTest
     : public DeviceCloudPolicyManagerChromeOSTest {
  public:
   void Done(EnrollmentStatus status) {
     status_ = status;
     done_ = true;
   }
 
  protected:
   DeviceCloudPolicyManagerChromeOSEnrollmentTest()
@@ skipping 301 matching lines @@
 
 TEST_F(DeviceCloudPolicyManagerChromeOSEnrollmentBlankSystemSaltTest,
        RobotRefreshSaveFailed) {
   // Without the system salt, the robot token can't be stored.
   RunTest();
   ExpectFailedEnrollment(EnrollmentStatus::STATUS_ROBOT_REFRESH_STORE_FAILED);
 }
 
 }  // namespace
 }  // namespace policy