Unmanaged devices should forget device id/token

chrome/browser/policy/device_management_policy_provider_unittest.cc

 // Copyright (c) 2010 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 "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/device_management_policy_provider.h"
 #include "chrome/browser/policy/mock_configuration_policy_store.h"
 #include "chrome/browser/policy/mock_device_management_backend.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_service.h"
@@ skipping 11 matching lines @@
 using ::testing::InSequence;
 using ::testing::Mock;
 
 class DeviceManagementPolicyProviderTest : public testing::Test {
  public:
   DeviceManagementPolicyProviderTest()
       : ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_) {}
 
   virtual ~DeviceManagementPolicyProviderTest() {}
-
   virtual void SetUp() {
     profile_.reset(new TestingProfile);
     CreateNewBackend();
     CreateNewProvider();
   }
 
   void CreateNewBackend() {
     backend_ = new MockDeviceManagementBackend;
   }
 
   void CreateNewProvider() {
     provider_.reset(new DeviceManagementPolicyProvider(
         ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList(),
         backend_,
         profile_.get()));
     provider_->SetDeviceTokenFetcher(
         new TestingDeviceTokenFetcher(backend_,
                                       profile_.get(),
                                       provider_->GetTokenPath()));
     loop_.RunAllPending();
   }
 
+  FilePath GetTokenPath() const {

[markusheintz_, 2010/11/29 09:01:43]

Why was this introduced? It looks like it is only used once in the test below.
Inline?

+    return provider_->GetTokenPath();
+  }
+
   void SimulateSuccessfulLoginAndRunPending() {
     loop_.RunAllPending();
     profile_->GetTokenService()->IssueAuthTokenForTest(
         GaiaConstants::kDeviceManagementService, kTestToken);
     TestingDeviceTokenFetcher* fetcher =
         static_cast<TestingDeviceTokenFetcher*>(
             provider_->token_fetcher_.get());
     fetcher->SimulateLogin(kTestManagedDomainUsername);
     loop_.RunAllPending();
   }
@@ skipping 173 matching lines @@
   EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorServiceManagementTokenInvalid));
   EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendSucceedRegister());
   EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
   SimulateSuccessfulLoginAndRunPending();
 }
 
+// If the client is successfully managed, but the admin stops managing the
+// device, the client should notice and throw away the device token and id.
+TEST_F(DeviceManagementPolicyProviderTest, DeviceNoLongerManaged) {
+  InSequence s;
+  SetRefreshDelays(provider_.get(), 0, 0, 1000 * 1000, 1000);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedRegister());
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailPolicy(
+          DeviceManagementBackend::kErrorServiceManagementNotSupported));
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailRegister(
+          DeviceManagementBackend::kErrorServiceManagementNotSupported));
+  SimulateSuccessfulLoginAndRunPending();
+  FilePath token_path(GetTokenPath());
+  EXPECT_FALSE(file_util::PathExists(token_path));
+}
+
 }  // namespace policy