Fix policy invalidator lifecycle bugs for Android.

chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/sample_map.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/invalidation/fake_invalidation_service.h"
@@ skipping 22 matching lines @@
     POLICY_OBJECT_B
   };
 
   CloudPolicyInvalidatorTest();
 
   virtual void SetUp() OVERRIDE;
 
   virtual void TearDown() OVERRIDE;
 
   // Starts the invalidator which will be tested.
-  void StartInvalidator(bool initialize);
+  // |instantiate| determines if the invalidator should be instantiated.
+  // |start| determines if the invalidator should be started.
+  void StartInvalidator(bool instantiate, bool start);
   void StartInvalidator() {
-    StartInvalidator(true /* initialize */);
+    StartInvalidator(true /* instantiate */, true /* start */);
   }
 
+  // Calls Stop on the invalidator.
+  void StopInvalidator();
+
+  // Calls Shutdown on the invalidator. Test must call DestroyInvalidator
+  // afterwards to prevent Shutdown from being called twice.
+  void ShutdownInvalidator();
+
+  // Destroys the invalidator.
+  void DestroyInvalidator();
+
   // Simulates storing a new policy to the policy store.
   // |object| determines which policy object the store will report the
   // invalidator should register for. May be POLICY_OBJECT_NONE for no object.
   // |invalidation_version| determines what invalidation the store will report.
   // |policy_changed| determines whether the store will report that the
   // policy changed.
   // |timestamp| determines the response timestamp the store will report.
   void StorePolicy(
       PolicyObject object,
       int64 invalidation_version,
@@ skipping 60 matching lines @@
   base::HistogramBase::Count GetInvalidationCount(bool with_payload);
 
   // CloudPolicyInvalidationHandler:
   virtual void SetInvalidationInfo(
       int64 version,
       const std::string& payload) OVERRIDE;
   virtual void InvalidatePolicy() OVERRIDE;
   virtual void OnInvalidatorStateChanged(bool invalidations_enabled) OVERRIDE;
 
  private:
+  // Get a pointer to the invalidation service.
+  invalidation::InvalidationService* GetInvalidationService();
+
   // Returns the object id of the given policy object.
   const invalidation::ObjectId& GetPolicyObjectId(PolicyObject object) const;
 
   // Get histogram samples for the given histogram.
   scoped_ptr<base::HistogramSamples> GetHistogramSamples(
       const std::string& name) const;
 
   // Objects the invalidator depends on.
   invalidation::FakeInvalidationService invalidation_service_;
   MockCloudPolicyStore store_;
@@ skipping 53 matching lines @@
   refresh_samples_ = GetHistogramSamples(kMetricPolicyRefresh);
   invalidations_samples_ = GetHistogramSamples(kMetricPolicyInvalidations);
 }
 
 void CloudPolicyInvalidatorTest::TearDown() {
   EXPECT_FALSE(invalidation_service_.ReceivedInvalidAcknowledgement());
   if (invalidator_)
     invalidator_->Shutdown();
 }
 
-void CloudPolicyInvalidatorTest::StartInvalidator(bool initialize) {
-  invalidator_.reset(new CloudPolicyInvalidator(
-      this /* invalidation_handler */,
-      &store_,
-      task_runner_));
-  if (initialize)
-    invalidator_->InitializeWithService(&invalidation_service_);
+void CloudPolicyInvalidatorTest::StartInvalidator(bool instantiate,
+                                                  bool start) {
+  if (instantiate) {
+    invalidator_.reset(new CloudPolicyInvalidator(
+        base::Bind(
+            &CloudPolicyInvalidatorTest::GetInvalidationService,
+            base::Unretained(this)),
+        this /* invalidation_handler */,
+        &store_,
+        task_runner_));
+  }
+  if (start)
+    invalidator_->Start();
+}
+
+void CloudPolicyInvalidatorTest::StopInvalidator() {
+  invalidator_->Stop();
+}
+
+void CloudPolicyInvalidatorTest::ShutdownInvalidator() {
+  invalidator_->Shutdown();
+}
+
+void CloudPolicyInvalidatorTest::DestroyInvalidator() {
+  invalidator_.reset();
 }
 
 void CloudPolicyInvalidatorTest::StorePolicy(
     PolicyObject object,
     int64 invalidation_version,
     bool policy_changed,
     int64 timestamp) {
   enterprise_management::PolicyData* data =
       new enterprise_management::PolicyData();
   if (object != POLICY_OBJECT_NONE) {
@@ skipping 137 matching lines @@
 void CloudPolicyInvalidatorTest::OnInvalidatorStateChanged(
     bool invalidations_enabled) {
   if (invalidator_.get())
     EXPECT_EQ(invalidations_enabled, invalidator_->invalidations_enabled());
   if (invalidations_enabled)
     ++state_change_enabled_callback_count_;
   else
     ++state_change_disabled_callback_count_;
 }
 
+invalidation::InvalidationService*
+CloudPolicyInvalidatorTest::GetInvalidationService() {
+  return &invalidation_service_;
+}
+
 const invalidation::ObjectId& CloudPolicyInvalidatorTest::GetPolicyObjectId(
     PolicyObject object) const {
   EXPECT_TRUE(object == POLICY_OBJECT_A || object == POLICY_OBJECT_B);
   return object == POLICY_OBJECT_A ? object_id_a_ : object_id_b_;
 }
 
 scoped_ptr<base::HistogramSamples>
     CloudPolicyInvalidatorTest::GetHistogramSamples(
         const std::string& name) const {
   base::HistogramBase* histogram =
       base::StatisticsRecorder::FindHistogram(name);
   if (!histogram)
     return scoped_ptr<base::HistogramSamples>(new base::SampleMap());
   return histogram->SnapshotSamples();
 }
 
-TEST_F(CloudPolicyInvalidatorTest, Uninitialized) {
-  // No invalidations should be processed if the invalidator is not intialized.
-  StartInvalidator(false /* initialize */);
+TEST_F(CloudPolicyInvalidatorTest, Unstarted) {
+  // No invalidations should be processed if the invalidator is not started.
+  StartInvalidator(true /* instantiate */, false /* start */);
   StorePolicy(POLICY_OBJECT_A);
   FireInvalidation(POLICY_OBJECT_A);
   EXPECT_TRUE(CheckInvalidateNotCalled());
 }
 
 TEST_F(CloudPolicyInvalidatorTest, RegisterOnStoreLoaded) {
   // No registration when store is not loaded.
   StartInvalidator();
   EXPECT_TRUE(CheckStateChangedNotCalled());
   FireInvalidation(POLICY_OBJECT_A);
@@ skipping 173 matching lines @@
   syncer::AckHandle ack = FireInvalidation(POLICY_OBJECT_A, 3, "test");
 
   // Ensure that the invalidate callback is not made and the invalidation is
   // acknowledged if the store is loaded with the latest version before the
   // callback is invoked.
   StorePolicy(POLICY_OBJECT_A, 3);
   EXPECT_TRUE(IsInvalidationAcknowledged(ack));
   EXPECT_TRUE(CheckInvalidateNotCalled());
 }
 
+TEST_F(CloudPolicyInvalidatorTest, NoCallbackAfterShutdown) {
+  // Generate an invalidation.
+  StorePolicy(POLICY_OBJECT_A);
+  StartInvalidator();
+  syncer::AckHandle ack = FireInvalidation(POLICY_OBJECT_A, 3, "test");
+
+  // Ensure that the invalidate callback is not made after the invalidator is
+  // shut down.
+  ShutdownInvalidator();
+  EXPECT_TRUE(CheckInvalidateNotCalled());
+  DestroyInvalidator();
+}
+
 TEST_F(CloudPolicyInvalidatorTest, StateChanged) {
   // Before registration, changes to the invalidation service state should not
   // generate change state notifications.
   StartInvalidator();
   DisableInvalidationService();
   EnableInvalidationService();
   EXPECT_TRUE(CheckStateChangedNotCalled());
 
   // After registration, changes to the invalidation service state should
   // generate notifications.
@@ skipping 21 matching lines @@
 
   // When the invalidation service is disabled, changes to the registration
   // state should not generate notifications.
   DisableInvalidationService();
   EXPECT_TRUE(CheckStateChangedCalled(false));
   StorePolicy(POLICY_OBJECT_NONE);
   StorePolicy(POLICY_OBJECT_A);
   EXPECT_TRUE(CheckStateChangedNotCalled());
 }
 
+TEST_F(CloudPolicyInvalidatorTest, Stop) {
+  // Generate an invalidation.
+  StorePolicy(POLICY_OBJECT_A);
+  StartInvalidator();
+  syncer::AckHandle ack = FireInvalidation(POLICY_OBJECT_A, 3, "test");
+  EXPECT_TRUE(CheckStateChangedCalled(true));
+
+  // Ensure that the invalidate callback is not made after stopping the
+  // invalidator, but a call to indicate that invalidations are disabled is
+  // made.
+  StopInvalidator();
+  EXPECT_TRUE(CheckInvalidateNotCalled());
+  EXPECT_TRUE(CheckStateChangedCalled(false));
+
+  // Ensure that invalidation service events do not cause callbacks to be
+  // invoked while the invalidator is stopped.
+  FireInvalidation(POLICY_OBJECT_A, 4, "test");
+  EXPECT_TRUE(CheckInvalidateNotCalled());
+  DisableInvalidationService();
+  EXPECT_TRUE(CheckStateChangedNotCalled());
+  EnableInvalidationService();
+  EXPECT_TRUE(CheckStateChangedNotCalled());
+
+  // Ensure that the invalidator returns to normal after restarting.
+  StartInvalidator(false /* instantiate */, true /* start */);
+  EXPECT_TRUE(CheckInvalidateNotCalled());
+  EXPECT_TRUE(CheckStateChangedCalled(true));
+  FireInvalidation(POLICY_OBJECT_A, 4, "test");
+  EXPECT_TRUE(CheckInvalidationInfo(4, "test"));
+  EXPECT_TRUE(CheckInvalidateCalled(false /* unknown_version */));
+  DisableInvalidationService();
+  EXPECT_TRUE(CheckStateChangedCalled(false));
+}
+
 TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsUnregistered) {
   // Store loads occurring before invalidation registration are not counted.
   StartInvalidator();
   StorePolicy(POLICY_OBJECT_NONE, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_NONE, 0, true /* policy_changed */);
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_CHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_CHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
@@ skipping 80 matching lines @@
   FireInvalidation(POLICY_OBJECT_A);
   FireInvalidation(POLICY_OBJECT_A, 3, "test");
   FireInvalidation(POLICY_OBJECT_A, 4, "test");
 
   // Verify that received invalidations metrics are correct.
   EXPECT_EQ(3, GetInvalidationCount(false /* with_payload */));
   EXPECT_EQ(4, GetInvalidationCount(true /* with_payload */));
 }
 
 }  // namespace policy