Separate UMA histograms for user and device policy invalidation

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"
@@ skipping 11 matching lines @@
 #include "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
 #include "components/invalidation/invalidation_util.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/cloud_policy_refresh_scheduler.h"
 #include "components/policy/core/common/cloud/enterprise_metrics.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_client.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_store.h"
 #include "components/policy/core/common/policy_types.h"
 #include "policy/policy_constants.h"
-#include "policy/proto/device_management_backend.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace em = enterprise_management;
+
 namespace policy {
 
 class CloudPolicyInvalidatorTest : public testing::Test {
  protected:
   // Policy objects which can be used in tests.
   enum PolicyObject {
     POLICY_OBJECT_NONE,
     POLICY_OBJECT_A,
     POLICY_OBJECT_B
   };
 
   CloudPolicyInvalidatorTest();
 
-  virtual void SetUp() OVERRIDE;
-
   virtual void TearDown() OVERRIDE;
 
   // Starts the invalidator which will be tested.
   // |initialize| determines if the invalidator should be initialized.
   // |start_refresh_scheduler| determines if the refresh scheduler should start.
   void StartInvalidator(bool initialize, bool start_refresh_scheduler);
   void StartInvalidator() {
     StartInvalidator(true /* initialize */, true /* start_refresh_scheduler */);
   }
 
@@ skipping 79 matching lines @@
   bool InvalidationsEnabled();
 
   // Determines if the invalidation with the given ack handle has been
   // acknowledged.
   bool IsInvalidationAcknowledged(const syncer::Invalidation& invalidation);
 
   // Determines if the invalidator has registered for an object with the
   // invalidation service.
   bool IsInvalidatorRegistered();
 
-  // Get the current count for the given metric.
-  base::HistogramBase::Count GetCount(MetricPolicyRefresh metric);
-  base::HistogramBase::Count GetInvalidationCount(PolicyInvalidationType type);
-
   // Advance the test clock.
   void AdvanceClock(base::TimeDelta delta);
 
   // Get the current time on the test clock.
   base::Time Now();
 
   // Translate a version number into an appropriate invalidation version (which
   // is based on the current time).
   int64 V(int version);
 
   // Get an invalidation version for the given time.
   int64 GetVersion(base::Time time);
 
+  // Get the policy type that the |invalidator_| is responsible for.
+  virtual em::DeviceRegisterRequest::Type GetPolicyType() const;
+
  private:
   // Checks that the policy was refreshed due to an invalidation with the given
   // base delay.
   bool CheckPolicyRefreshed(base::TimeDelta delay);
 
   // Checks that the policy was refreshed the given number of times.
   bool CheckPolicyRefreshCount(int count);
 
   // 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;
-
   base::MessageLoop loop_;
 
   // Objects the invalidator depends on.
   invalidation::FakeInvalidationService invalidation_service_;
   MockCloudPolicyStore store_;
   CloudPolicyCore core_;
   MockCloudPolicyClient* client_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::SimpleTestClock* clock_;
 
   // The invalidator which will be tested.
   scoped_ptr<CloudPolicyInvalidator> invalidator_;
 
   // Object ids for the test policy objects.
   invalidation::ObjectId object_id_a_;
   invalidation::ObjectId object_id_b_;
 
   // Fake policy values which are alternated to cause the store to report a
   // changed policy.
   const char* policy_value_a_;
   const char* policy_value_b_;
 
   // The currently used policy value.
   const char* policy_value_cur_;
-
-  // Stores starting histogram counts for kMetricPolicyRefresh.
-  scoped_ptr<base::HistogramSamples> refresh_samples_;
-
-  // Stores starting histogram counts for kMetricPolicyInvalidations.
-  scoped_ptr<base::HistogramSamples> invalidations_samples_;
 };
 
 CloudPolicyInvalidatorTest::CloudPolicyInvalidatorTest()
     : core_(PolicyNamespaceKey(dm_protocol::kChromeUserPolicyType,
                                std::string()),
             &store_,
             loop_.message_loop_proxy()),
       client_(NULL),
       task_runner_(new base::TestSimpleTaskRunner()),
       clock_(new base::SimpleTestClock()),
       object_id_a_(135, "asdf"),
       object_id_b_(246, "zxcv"),
       policy_value_a_("asdf"),
       policy_value_b_("zxcv"),
       policy_value_cur_(policy_value_a_) {
   clock_->SetNow(
       base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(987654321));
 }
 
-void CloudPolicyInvalidatorTest::SetUp() {
-  base::StatisticsRecorder::Initialize();
-  refresh_samples_ = GetHistogramSamples(kMetricPolicyRefresh);
-  invalidations_samples_ = GetHistogramSamples(kMetricPolicyInvalidations);
-}
-
 void CloudPolicyInvalidatorTest::TearDown() {
   if (invalidator_)
     invalidator_->Shutdown();
   core_.Disconnect();
 }
 
 void CloudPolicyInvalidatorTest::StartInvalidator(
     bool initialize,
     bool start_refresh_scheduler) {
   invalidator_.reset(new CloudPolicyInvalidator(
+      GetPolicyType(),
       &core_,
       task_runner_,
       scoped_ptr<base::Clock>(clock_)));
   if (start_refresh_scheduler) {
     ConnectCore();
     StartRefreshScheduler();
   }
   if (initialize)
     InitializeInvalidator();
 }
@@ skipping 23 matching lines @@
 void CloudPolicyInvalidatorTest::DisconnectCore() {
   client_ = NULL;
   core_.Disconnect();
 }
 
 void CloudPolicyInvalidatorTest::StorePolicy(
     PolicyObject object,
     int64 invalidation_version,
     bool policy_changed,
     const base::Time& time) {
-  enterprise_management::PolicyData* data =
-      new enterprise_management::PolicyData();
+  em::PolicyData* data = new enterprise_management::PolicyData();

[Joao da Silva, 2014/08/11 14:12:01]

new em::PolicyData

[bartfab (slow), 2014/08/11 14:21:31]

Done.

   if (object != POLICY_OBJECT_NONE) {
     data->set_invalidation_source(GetPolicyObjectId(object).source());
     data->set_invalidation_name(GetPolicyObjectId(object).name());
   }
   data->set_timestamp((time - base::Time::UnixEpoch()).InMilliseconds());
   // Swap the policy value if a policy change is desired.
   if (policy_changed)
     policy_value_cur_ = policy_value_cur_ == policy_value_a_ ?
         policy_value_b_ : policy_value_a_;
   data->set_policy_value(policy_value_cur_);
@@ skipping 79 matching lines @@
 
   EXPECT_FALSE(IsUnsent(invalidation));
   return !invalidation_service_.GetMockAckHandler()->IsUnacked(invalidation);
 }
 
 bool CloudPolicyInvalidatorTest::IsInvalidatorRegistered() {
   return !invalidation_service_.invalidator_registrar()
       .GetRegisteredIds(invalidator_.get()).empty();
 }
 
-base::HistogramBase::Count CloudPolicyInvalidatorTest::GetCount(
-    MetricPolicyRefresh metric) {
-  return GetHistogramSamples(kMetricPolicyRefresh)->GetCount(metric) -
-      refresh_samples_->GetCount(metric);
-}
-
-base::HistogramBase::Count CloudPolicyInvalidatorTest::GetInvalidationCount(
-    PolicyInvalidationType type) {
-  return GetHistogramSamples(kMetricPolicyInvalidations)->GetCount(type) -
-      invalidations_samples_->GetCount(type);
-}
-
 void CloudPolicyInvalidatorTest::AdvanceClock(base::TimeDelta delta) {
   clock_->Advance(delta);
 }
 
 base::Time CloudPolicyInvalidatorTest::Now() {
   return clock_->Now();
 }
 
 int64 CloudPolicyInvalidatorTest::V(int version) {
   return GetVersion(Now()) + version;
 }
 
 int64 CloudPolicyInvalidatorTest::GetVersion(base::Time time) {
   return (time - base::Time::UnixEpoch()).InMicroseconds();
 }
 
+em::DeviceRegisterRequest::Type
+CloudPolicyInvalidatorTest::GetPolicyType() const {
+#if defined(OS_CHROMEOS)
+    return em::DeviceRegisterRequest::USER;
+#elif defined(OS_ANDROID)
+    return em::DeviceRegisterRequest::ANDROID_BROWSER;
+#elif defined(OS_IOS)
+    return em::DeviceRegisterRequest::IOS_BROWSER;
+#else
+    return em::DeviceRegisterRequest::BROWSER;
+#endif
+}
+
 bool CloudPolicyInvalidatorTest::CheckPolicyRefreshed(base::TimeDelta delay) {
   base::TimeDelta max_delay = delay + base::TimeDelta::FromMilliseconds(
       CloudPolicyInvalidator::kMaxFetchDelayMin);
 
   if (task_runner_->GetPendingTasks().empty())
     return false;
   base::TimeDelta actual_delay = task_runner_->GetPendingTasks().back().delay;
   EXPECT_GE(actual_delay, delay);
   EXPECT_LE(actual_delay, max_delay);
 
@@ skipping 17 matching lines @@
   base::RunLoop().RunUntilIdle();
   return testing::Mock::VerifyAndClearExpectations(client_);
 }
 
 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 initialized.
   StartInvalidator(false /* initialize */, true /* start_refresh_scheduler */);
   StorePolicy(POLICY_OBJECT_A);
   EXPECT_FALSE(IsInvalidatorRegistered());
   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 }
 
 TEST_F(CloudPolicyInvalidatorTest, RefreshSchedulerNotStarted) {
@@ skipping 312 matching lines @@
   StartRefreshScheduler();
   EXPECT_TRUE(CheckPolicyNotRefreshed());
   EXPECT_TRUE(InvalidationsEnabled());
   FireInvalidation(POLICY_OBJECT_A, V(5), "test");
   EXPECT_TRUE(CheckInvalidationInfo(V(5), "test"));
   EXPECT_TRUE(CheckPolicyRefreshed());
   DisableInvalidationService();
   EXPECT_FALSE(InvalidationsEnabled());
 }
 
-TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsUnregistered) {
+class CloudPolicyInvalidatorUserTypedTest
+    : public CloudPolicyInvalidatorTest,
+      public testing::WithParamInterface<em::DeviceRegisterRequest::Type>  {
+ protected:
+  // CloudPolicyInvalidatorTest:
+  virtual void SetUp() OVERRIDE;
+
+  // Get the current count for the given metric.
+  base::HistogramBase::Count GetCount(MetricPolicyRefresh metric);
+  base::HistogramBase::Count GetInvalidationCount(PolicyInvalidationType type);
+
+ private:
+  // CloudPolicyInvalidatorTest:
+  virtual em::DeviceRegisterRequest::Type GetPolicyType() const OVERRIDE;
+
+  // Get histogram samples for the given histogram.
+  scoped_ptr<base::HistogramSamples> GetHistogramSamples(
+      const std::string& name) const;
+
+  // Stores starting histogram counts for kMetricPolicyRefresh.
+  scoped_ptr<base::HistogramSamples> refresh_samples_;
+
+  // Stores starting histogram counts for kMetricPolicyInvalidations.
+  scoped_ptr<base::HistogramSamples> invalidations_samples_;
+};
+
+void CloudPolicyInvalidatorUserTypedTest::SetUp() {
+  base::StatisticsRecorder::Initialize();
+  refresh_samples_ = GetHistogramSamples(
+      GetPolicyType() == em::DeviceRegisterRequest::DEVICE ?
+          kMetricDevicePolicyRefresh : kMetricUserPolicyRefresh);
+  invalidations_samples_ = GetHistogramSamples(
+      GetPolicyType() == em::DeviceRegisterRequest::DEVICE ?
+          kMetricDevicePolicyInvalidations : kMetricUserPolicyInvalidations);
+}
+
+base::HistogramBase::Count CloudPolicyInvalidatorUserTypedTest::GetCount(
+    MetricPolicyRefresh metric) {
+  return GetHistogramSamples(
+      GetPolicyType() == em::DeviceRegisterRequest::DEVICE ?
+          kMetricDevicePolicyRefresh : kMetricUserPolicyRefresh)->
+              GetCount(metric) - refresh_samples_->GetCount(metric);
+}
+
+base::HistogramBase::Count
+CloudPolicyInvalidatorUserTypedTest::GetInvalidationCount(
+    PolicyInvalidationType type) {
+  return GetHistogramSamples(
+      GetPolicyType() == em::DeviceRegisterRequest::DEVICE ?
+          kMetricDevicePolicyInvalidations : kMetricUserPolicyInvalidations)->
+          GetCount(type) - invalidations_samples_->GetCount(type);
+}
+
+em::DeviceRegisterRequest::Type
+CloudPolicyInvalidatorUserTypedTest::GetPolicyType() const {
+  return GetParam();
+}
+
+scoped_ptr<base::HistogramSamples>
+CloudPolicyInvalidatorUserTypedTest::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_P(CloudPolicyInvalidatorUserTypedTest, 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));
 }
 
-TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsNoInvalidations) {
+TEST_P(CloudPolicyInvalidatorUserTypedTest, RefreshMetricsNoInvalidations) {
   // Store loads occurring while registered should be differentiated depending
   // on whether the invalidation service was enabled or not.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
 
   // Initially, invalidations have not been enabled past the grace period, so
   // invalidations are OFF.
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
   EXPECT_EQ(1, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
@@ skipping 30 matching lines @@
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 
   EXPECT_EQ(2, GetCount(METRIC_POLICY_REFRESH_CHANGED));
   EXPECT_EQ(4, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
   EXPECT_EQ(6, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_CHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
 }
 
-TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsInvalidation) {
+TEST_P(CloudPolicyInvalidatorUserTypedTest, RefreshMetricsInvalidation) {
   // Store loads after an invalidation are counted as invalidated, even if
   // the loads do not result in the invalidation being acknowledged.
   StartInvalidator();
   StorePolicy(POLICY_OBJECT_A);
   AdvanceClock(base::TimeDelta::FromSeconds(
       CloudPolicyInvalidator::kInvalidationGracePeriod));
   FireInvalidation(POLICY_OBJECT_A, V(5), "test");
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, V(5), true /* policy_changed */);
 
   // Store loads after the invalidation is complete are not counted as
   // invalidated.
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 
   EXPECT_EQ(3, GetCount(METRIC_POLICY_REFRESH_CHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
   EXPECT_EQ(4, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
   EXPECT_EQ(2, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_CHANGED));
   EXPECT_EQ(1, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
 }
 
-TEST_F(CloudPolicyInvalidatorTest, ExpiredInvalidations) {
+TEST_P(CloudPolicyInvalidatorUserTypedTest, ExpiredInvalidations) {
   StorePolicy(POLICY_OBJECT_A, 0, false, Now());
   StartInvalidator();
 
   // Invalidations fired before the last fetch time (adjusted by max time delta)
   // should be ignored.
   base::Time time = Now() - base::TimeDelta::FromSeconds(
       CloudPolicyInvalidator::kMaxInvalidationTimeDelta + 300);
   syncer::Invalidation inv =
       FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
   ASSERT_TRUE(IsInvalidationAcknowledged(inv));
@@ skipping 40 matching lines @@
   ASSERT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 
   // Verify that received invalidations metrics are correct.
   EXPECT_EQ(1, GetInvalidationCount(POLICY_INVALIDATION_TYPE_NO_PAYLOAD));
   EXPECT_EQ(3, GetInvalidationCount(POLICY_INVALIDATION_TYPE_NORMAL));
   EXPECT_EQ(2,
             GetInvalidationCount(POLICY_INVALIDATION_TYPE_NO_PAYLOAD_EXPIRED));
   EXPECT_EQ(2, GetInvalidationCount(POLICY_INVALIDATION_TYPE_EXPIRED));
 }
 
+INSTANTIATE_TEST_CASE_P(
+    CloudPolicyInvalidatorUserTypedTestInstance,
+    CloudPolicyInvalidatorUserTypedTest,
+#if defined(OS_CHROMEOS)
+    testing::Values(em::DeviceRegisterRequest::USER,
+                    em::DeviceRegisterRequest::DEVICE));
+#elif defined(OS_ANDROID)
+    testing::Values(em::DeviceRegisterRequest::ANDROID_BROWSER));
+#elif defined(OS_IOS)
+    testing::Values(em::DeviceRegisterRequest::IOS_BROWSER));
+#else
+    testing::Values(em::DeviceRegisterRequest::BROWSER));
+#endif
+
 }  // namespace policy