Add DeviceSettingsService.

chrome/browser/policy/cloud_policy_validator_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 <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 18 matching lines @@
   EXPECT_EQ(expected_status, arg0->status());
 };
 
 class CloudPolicyValidatorTest : public testing::Test {
  public:
   CloudPolicyValidatorTest()
       : loop_(MessageLoop::TYPE_UI),
         timestamp_(base::Time::UnixEpoch() +
                    base::TimeDelta::FromMilliseconds(
                        PolicyBuilder::kFakeTimestamp)),
-        file_thread_(content::BrowserThread::FILE, &loop_) {}
+        file_thread_(content::BrowserThread::FILE, &loop_) {
+    policy_.set_new_signing_key(PolicyBuilder::CreateTestNewSigningKey());

[pastarmovj, 2012/07/30 12:19:19]

Again I think that tests that don't need special keys e.g. key rotation etc.
will profit from using a hard coded key pair. On my machine ssh-keygen -b 2048
takes around 100ms so this doesn't seem like a premature optimization to me.

[Mattias Nissler (ping if slow), 2012/07/31 13:02:15]

Have you checked PolicyBuilder? This function actually returns a key object
created from static key data :)

+  }
 
   void Validate(testing::Action<void(UserCloudPolicyValidator*)> check_action) {
     std::vector<uint8> public_key;
     ASSERT_TRUE(
         PolicyBuilder::CreateTestSigningKey()->ExportPublicKey(&public_key));
 
     // Create a validator.
     policy_.Build();
     UserCloudPolicyValidator* validator =
         UserCloudPolicyValidator::Create(
             policy_.GetCopy(),
             base::Bind(&CloudPolicyValidatorTest::ValidationCompletion,
                        base::Unretained(this)));
-    validator->ValidateTimestamp(timestamp_, timestamp_);
+    validator->ValidateTimestamp(timestamp_, timestamp_, false);

[pastarmovj, 2012/07/30 12:19:19]

Given that we have some more degrees of freedom now it seems that maybe there is
more to be tested here now, namely the cross product of the two new flags.

[Mattias Nissler (ping if slow), 2012/07/31 13:02:15]

Done.

     validator->ValidateUsername(PolicyBuilder::kFakeUsername);
     validator->ValidateDomain(PolicyBuilder::kFakeDomain);
     validator->ValidateDMToken(PolicyBuilder::kFakeToken);
     validator->ValidatePolicyType(dm_protocol::kChromeUserPolicyType);
     validator->ValidatePayload();
     validator->ValidateSignature(std::string(public_key.begin(),
-                                             public_key.end()));
+                                             public_key.end()),
+                                 true);
     validator->ValidateInitialKey();
 
     // Run validation and check the result.
     EXPECT_CALL(*this, ValidationCompletion(validator)).WillOnce(check_action);
     validator->StartValidation();
     loop_.RunAllPending();
     Mock::VerifyAndClearExpectations(this);
   }
 
   void CheckSuccessfulValidation(UserCloudPolicyValidator* validator) {
@@ skipping 142 matching lines @@
 TEST_F(CloudPolicyValidatorTest, ErrorInvalidPublicKeySignature) {
   policy_.set_signing_key(scoped_ptr<crypto::RSAPrivateKey>());
   policy_.set_new_signing_key(scoped_ptr<crypto::RSAPrivateKey>());
   policy_.policy().set_new_public_key_signature("invalid");
   Validate(CheckStatus(CloudPolicyValidatorBase::VALIDATION_BAD_SIGNATURE));
 }
 
 }  // namespace
 
 }  // namespace policy