Fix policy invalidator lifecycle bugs for Android.

chrome/browser/policy/cloud/cloud_policy_manager_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/policy/cloud/cloud_policy_manager.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "chrome/browser/invalidation/fake_invalidation_service.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
 #include "chrome/browser/policy/cloud/mock_cloud_policy_client.h"
 #include "chrome/browser/policy/cloud/mock_cloud_policy_store.h"
 #include "chrome/browser/policy/cloud/policy_builder.h"
 #include "chrome/browser/policy/configuration_policy_provider_test.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
@@ skipping 121 matching lines @@
                                dm_protocol::kChromeUserPolicyType,
                                std::string()),
                            store) {}
   virtual ~TestCloudPolicyManager() {}
 
   // Publish the protected members for testing.
   using CloudPolicyManager::client;
   using CloudPolicyManager::store;
   using CloudPolicyManager::service;
   using CloudPolicyManager::CheckAndPublishPolicy;
-  using CloudPolicyManager::StartRefreshScheduler;
+  using CloudPolicyManager::StartInvalidator;
+  using CloudPolicyManager::StopInvalidator;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestCloudPolicyManager);
 };
 
 MATCHER_P(ProtoMatches, proto, "") {
   return arg.SerializePartialAsString() == proto.SerializePartialAsString();
 }
 
 class CloudPolicyManagerTest : public testing::Test {
@@ skipping 16 matching lines @@
     manager_->Init();
     Mock::VerifyAndClearExpectations(&store_);
     manager_->AddObserver(&observer_);
   }
 
   virtual void TearDown() OVERRIDE {
     manager_->RemoveObserver(&observer_);
     manager_->Shutdown();
   }
 
-  // Sets up for an invalidations test.
+  // Creates the invalidator object for an invalidations test.
   void CreateInvalidator() {
     // Add the invalidation registration info to the policy data.
     em::PolicyData* policy_data = new em::PolicyData(policy_.policy_data());
     policy_data->set_invalidation_source(12345);
     policy_data->set_invalidation_name("12345");
     store_.policy_.reset(policy_data);
 
     // Connect the core.
     MockCloudPolicyClient* client = new MockCloudPolicyClient();
     EXPECT_CALL(*client, SetupRegistration(_, _));
     manager_->core()->Connect(scoped_ptr<CloudPolicyClient>(client));
+    manager_->core()->StartRefreshScheduler();
 
     // Create invalidation objects.
     task_runner_ = new base::TestSimpleTaskRunner();
     invalidation_service_.reset(new invalidation::FakeInvalidationService());
     invalidator_.reset(new CloudPolicyInvalidator(
+        base::Bind(
+            &CloudPolicyManagerTest::GetInvalidationService,
+            base::Unretained(this)),
         manager_.get(),
         manager_->core()->store(),
         task_runner_));
   }
 
   void ShutdownInvalidator() {
     invalidator_->Shutdown();
   }
 
-  // Call EnableInvalidations on the manager.
-  void EnableInvalidations() {
-    manager_->EnableInvalidations(
-        base::Bind(
-            &CloudPolicyInvalidator::InitializeWithService,
-            base::Unretained(invalidator_.get()),
-            base::Unretained(invalidation_service_.get())));
+  // Get a pointer to the invalidation service.
+  invalidation::InvalidationService* GetInvalidationService() {
+    return invalidation_service_.get();
   }
 
   // Determine if the invalidator has registered with the invalidation service.
   bool IsInvalidatorRegistered() {
     syncer::ObjectIdSet object_ids =
         invalidation_service_->invalidator_registrar().GetAllRegisteredIds();
     return object_ids.size() == 1 &&
         object_ids.begin()->source() == 12345 &&
         object_ids.begin()->name() == "12345";
   }
@@ skipping 161 matching lines @@
 TEST_F(CloudPolicyManagerTest, SignalOnError) {
   // Simulate a failed load and verify that it triggers OnUpdatePolicy().
   store_.policy_.reset(new em::PolicyData(policy_.policy_data()));
   EXPECT_CALL(observer_, OnUpdatePolicy(manager_.get()));
   store_.NotifyStoreError();
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
 }
 
-TEST_F(CloudPolicyManagerTest, EnableInvalidationsBeforeRefreshScheduler) {
+TEST_F(CloudPolicyManagerTest, StartInvalidatorAfterSetInvalidator) {
   CreateInvalidator();
+  base::WeakPtrFactory<CloudPolicyInvalidator> weak_factory(invalidator_.get());
   EXPECT_TRUE(IsInvalidatorUnregistered());
-  EnableInvalidations();
+  manager_->SetInvalidator(weak_factory.GetWeakPtr());
   EXPECT_TRUE(IsInvalidatorUnregistered());
-  manager_->StartRefreshScheduler();
+  manager_->StartInvalidator();
   EXPECT_TRUE(IsInvalidatorRegistered());
   ShutdownInvalidator();
 }
 
-TEST_F(CloudPolicyManagerTest, EnableInvalidationsAfterRefreshScheduler) {
+TEST_F(CloudPolicyManagerTest, StartInvalidatorBeforeSetInvalidator) {
   CreateInvalidator();
+  base::WeakPtrFactory<CloudPolicyInvalidator> weak_factory(invalidator_.get());
   EXPECT_TRUE(IsInvalidatorUnregistered());
-  manager_->StartRefreshScheduler();
+  manager_->StartInvalidator();
   EXPECT_TRUE(IsInvalidatorUnregistered());
-  EnableInvalidations();
+  manager_->SetInvalidator(weak_factory.GetWeakPtr());
   EXPECT_TRUE(IsInvalidatorRegistered());
   ShutdownInvalidator();
 }
 
+TEST_F(CloudPolicyManagerTest, StartAndStopInvalidatorBeforeSetInvalidator) {
+  CreateInvalidator();
+  base::WeakPtrFactory<CloudPolicyInvalidator> weak_factory(invalidator_.get());
+  EXPECT_TRUE(IsInvalidatorUnregistered());
+  manager_->StartInvalidator();
+  EXPECT_TRUE(IsInvalidatorUnregistered());
+  manager_->StopInvalidator();
+  EXPECT_TRUE(IsInvalidatorUnregistered());
+  manager_->SetInvalidator(weak_factory.GetWeakPtr());
+  EXPECT_TRUE(IsInvalidatorUnregistered());
+  ShutdownInvalidator();
+}
+
+TEST_F(CloudPolicyManagerTest, StopInvalidator) {
+  CreateInvalidator();
+  base::WeakPtrFactory<CloudPolicyInvalidator> weak_factory(invalidator_.get());
+  manager_->SetInvalidator(weak_factory.GetWeakPtr());
+  manager_->StartInvalidator();
+  EXPECT_TRUE(IsInvalidatorRegistered());
+  manager_->StopInvalidator();
+  EXPECT_TRUE(IsInvalidatorUnregistered());
+  manager_->StartInvalidator();
+  EXPECT_TRUE(IsInvalidatorRegistered());
+  ShutdownInvalidator();
+}
+
+TEST_F(CloudPolicyManagerTest, InvalidateInvalidatorPointer) {
+  CreateInvalidator();
+  base::WeakPtrFactory<CloudPolicyInvalidator> weak_factory(invalidator_.get());
+  manager_->SetInvalidator(weak_factory.GetWeakPtr());
+  manager_->StartInvalidator();
+  EXPECT_TRUE(IsInvalidatorRegistered());
+  ShutdownInvalidator();
+  weak_factory.InvalidateWeakPtrs();
+  EXPECT_TRUE(IsInvalidatorRegistered());
+  manager_->StopInvalidator();
+  EXPECT_TRUE(IsInvalidatorRegistered());
+  manager_->StartInvalidator();
+  EXPECT_TRUE(IsInvalidatorRegistered());
+}
+
 }  // namespace
 }  // namespace policy