Add device status reports to policy requests.

chrome/browser/policy/cloud_policy_controller_unittest.cc

 // Copyright (c) 2011 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/cloud_policy_controller.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/policy/cloud_policy_data_store.h"
@@ skipping 99 matching lines @@
   content::TestBrowserThread file_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyControllerTest);
 };
 
 // If a device token is present when the controller starts up, it should
 // fetch and apply policy.
 TEST_F(CloudPolicyControllerTest, StartupWithDeviceToken) {
   data_store_->SetupForTesting("fake_device_token", "device_id", "", "",
                                true);
-  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(DoAll(
+  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(DoAll(
       InvokeWithoutArgs(this, &CloudPolicyControllerTest::StopMessageLoop),
       MockDeviceManagementBackendSucceedSpdyCloudPolicy()));
   CreateNewController();
   loop_.RunAllPending();
   ExpectHasSpdyPolicy();
 }
 
 // If no device token is present when the controller starts up, it should
 // instruct the token_fetcher_ to fetch one.
 TEST_F(CloudPolicyControllerTest, StartupWithoutDeviceToken) {
@@ skipping 15 matching lines @@
 }
 
 // After policy has been fetched successfully, a new fetch should be triggered
 // after the refresh interval has timed out.
 TEST_F(CloudPolicyControllerTest, RefreshAfterSuccessfulPolicy) {
   data_store_->SetupForTesting("device_token", "device_id",
                                "DannoHelperDelegate@b.com",
                                "auth_token", true);
   {
     InSequence s;
-    EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(
+    EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(
         MockDeviceManagementBackendSucceedSpdyCloudPolicy());
-    EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(DoAll(
+    EXPECT_CALL(backend_,
+                ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(DoAll(
         InvokeWithoutArgs(this, &CloudPolicyControllerTest::StopMessageLoop),
         MockDeviceManagementBackendFailPolicy(
             DeviceManagementBackend::kErrorRequestFailed)));
   }
   CreateNewController();
   loop_.RunAllPending();
   ExpectHasSpdyPolicy();
 }
 
 // If policy fetching failed, it should be retried.
 TEST_F(CloudPolicyControllerTest, RefreshAfterError) {
   data_store_->SetupForTesting("device_token", "device_id",
                                "DannoHelperDelegateImpl@b.com",
                                "auth_token", true);
   {
     InSequence s;
-    EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(
+    EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(
         MockDeviceManagementBackendFailPolicy(
             DeviceManagementBackend::kErrorRequestFailed));
-    EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(DoAll(
+    EXPECT_CALL(backend_,
+                ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(DoAll(
         InvokeWithoutArgs(this,
                           &CloudPolicyControllerTest::StopMessageLoop),
         MockDeviceManagementBackendSucceedSpdyCloudPolicy()));
   }
   CreateNewController();
   loop_.RunAllPending();
   ExpectHasSpdyPolicy();
 }
 
 // If the backend reports that the device token was invalid, the controller
 // should instruct the token fetcher to fetch a new token.
 TEST_F(CloudPolicyControllerTest, InvalidToken) {
   data_store_->SetupForTesting("device_token", "device_id",
                                "standup@ten.am", "auth", true);
-  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(
+  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorServiceManagementTokenInvalid));
   EXPECT_CALL(*token_fetcher_.get(), FetchToken()).Times(1);
   CreateNewController();
   loop_.RunAllPending();
 }
 
 // If the backend reports that the device is unknown to the server, the
 // controller should instruct the token fetcher to fetch a new token.
 TEST_F(CloudPolicyControllerTest, DeviceNotFound) {
   data_store_->SetupForTesting("device_token", "device_id",
                                "me@you.com", "auth", true);
-  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(
+  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorServiceDeviceNotFound));
   EXPECT_CALL(*token_fetcher_.get(), FetchToken()).Times(1);
   CreateNewController();
   loop_.RunAllPending();
 }
 
 // If the backend reports that the device-id is already existing, the
 // controller should instruct the token fetcher to fetch a new token.
 TEST_F(CloudPolicyControllerTest, DeviceIdConflict) {
   data_store_->SetupForTesting("device_token", "device_id",
                                "me@you.com", "auth", true);
-  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(
+  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorServiceDeviceIdConflict));
   EXPECT_CALL(*token_fetcher_.get(), FetchToken()).Times(1);
   CreateNewController();
   loop_.RunAllPending();
 }
 
 // If the backend reports that the device is no longer managed, the controller
 // should instruct the token fetcher to fetch a new token (which will in turn
 // set and persist the correct 'unmanaged' state).
 TEST_F(CloudPolicyControllerTest, NoLongerManaged) {
   data_store_->SetupForTesting("device_token", "device_id",
                                "who@what.com", "auth", true);
-  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(
+  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorServiceManagementNotSupported));
   EXPECT_CALL(*token_fetcher_.get(), SetUnmanagedState()).Times(1);
   CreateNewController();
   loop_.RunAllPending();
 }
 
 // If the backend reports that the device has invalid serial number, the
 // controller should instruct the token fetcher not to fetch a new token
 // (which will in turn set and persist the correct 'sn invalid' state).
 TEST_F(CloudPolicyControllerTest, InvalidSerialNumber) {
   data_store_->SetupForTesting("device_token", "device_id",
                                "who@what.com", "auth", true);
-  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(
+  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorServiceInvalidSerialNumber));
   EXPECT_CALL(*token_fetcher_.get(), SetSerialNumberInvalidState()).Times(1);
   CreateNewController();
   loop_.RunAllPending();
 }
 
 TEST_F(CloudPolicyControllerTest, DontSetFetchingDoneWithoutTokens) {
   CreateNewWaitingCache();
   CreateNewController();
@@ skipping 21 matching lines @@
   loop_.RunAllPending();
   // User is in an unmanaged domain.
   EXPECT_TRUE(cache_->IsReady());
   EXPECT_TRUE(cache_->last_policy_refresh_time().is_null());
 }
 
 TEST_F(CloudPolicyControllerTest, SetFetchingDoneAfterPolicyFetch) {
   CreateNewWaitingCache();
   data_store_->SetupForTesting("device_token", "device_id",
                                "user@enterprise.com", "auth", true);
-  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(DoAll(
+  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(DoAll(
       InvokeWithoutArgs(this, &CloudPolicyControllerTest::StopMessageLoop),
       MockDeviceManagementBackendSucceedSpdyCloudPolicy()));
   CreateNewController();
   loop_.RunAllPending();
   EXPECT_TRUE(cache_->IsReady());
   EXPECT_FALSE(cache_->last_policy_refresh_time().is_null());
 }
 
 TEST_F(CloudPolicyControllerTest, SetFetchingDoneAfterPolicyFetchFails) {
   CreateNewWaitingCache();
   data_store_->SetupForTesting("device_token", "device_id",
                                "user@enterprise.com", "auth", true);
-  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(DoAll(
+  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _, _)).WillOnce(DoAll(
       InvokeWithoutArgs(this, &CloudPolicyControllerTest::StopMessageLoop),
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorRequestFailed)));
   CreateNewController();
   loop_.RunAllPending();
   EXPECT_TRUE(cache_->IsReady());
   EXPECT_TRUE(cache_->last_policy_refresh_time().is_null());
 }
 
 }  // namespace policy