Separate UMA histograms for user and device policy invalidation

chrome/browser/policy/cloud/cloud_policy_invalidator.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 "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
 
 #include "base/bind.h"
 #include "base/hash.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
@@ skipping 13 matching lines @@
 
 const int CloudPolicyInvalidator::kMissingPayloadDelay = 5;
 const int CloudPolicyInvalidator::kMaxFetchDelayDefault = 10000;
 const int CloudPolicyInvalidator::kMaxFetchDelayMin = 1000;
 const int CloudPolicyInvalidator::kMaxFetchDelayMax = 300000;
 const int CloudPolicyInvalidator::kInvalidationGracePeriod = 10;
 const int CloudPolicyInvalidator::kUnknownVersionIgnorePeriod = 30;
 const int CloudPolicyInvalidator::kMaxInvalidationTimeDelta = 300;
 
 CloudPolicyInvalidator::CloudPolicyInvalidator(
+    enterprise_management::DeviceRegisterRequest::Type type,
     CloudPolicyCore* core,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     scoped_ptr<base::Clock> clock)
     : state_(UNINITIALIZED),
+      type_(type),
       core_(core),
       task_runner_(task_runner),
       clock_(clock.Pass()),
       invalidation_service_(NULL),
       invalidations_enabled_(false),
       invalidation_service_enabled_(false),
       is_registered_(false),
       invalid_(false),
       invalidation_version_(0),
       unknown_version_invalidation_count_(0),
@@ skipping 86 matching lines @@
     state_ = STOPPED;
   }
 }
 
 void CloudPolicyInvalidator::OnStoreLoaded(CloudPolicyStore* store) {
   DCHECK(state_ == STARTED);
   DCHECK(thread_checker_.CalledOnValidThread());
   bool policy_changed = IsPolicyChanged(store->policy());
 
   if (is_registered_) {
-    // Update the kMetricPolicyRefresh histogram.
-    UMA_HISTOGRAM_ENUMERATION(
-        kMetricPolicyRefresh,
-        GetPolicyRefreshMetric(policy_changed),
-        METRIC_POLICY_REFRESH_SIZE);
+    // Update the kMetricDevicePolicyRefresh/kMetricUserPolicyRefresh histogram.
+    if (type_ == enterprise_management::DeviceRegisterRequest::DEVICE) {
+      UMA_HISTOGRAM_ENUMERATION(kMetricDevicePolicyRefresh,
+                                GetPolicyRefreshMetric(policy_changed),
+                                METRIC_POLICY_REFRESH_SIZE);
+    } else {
+      UMA_HISTOGRAM_ENUMERATION(kMetricUserPolicyRefresh,
+                                GetPolicyRefreshMetric(policy_changed),
+                                METRIC_POLICY_REFRESH_SIZE);
+    }
 
     // If the policy was invalid and the version stored matches the latest
     // invalidation version, acknowledge the latest invalidation.
     if (invalid_ && store->invalidation_version() == invalidation_version_)
       AcknowledgeInvalidation();
   }
 
   UpdateRegistration(store->policy());
   UpdateMaxFetchDelay(store->policy_map());
 }
@@ skipping 23 matching lines @@
   std::string payload;
   if (invalidation.is_unknown_version()) {
     version = -(++unknown_version_invalidation_count_);
   } else {
     version = invalidation.version();
     payload = invalidation.payload();
   }
 
   // Ignore the invalidation if it is expired.
   bool is_expired = IsInvalidationExpired(version);
-  UMA_HISTOGRAM_ENUMERATION(
-      kMetricPolicyInvalidations,
-      GetInvalidationMetric(payload.empty(), is_expired),
-      POLICY_INVALIDATION_TYPE_SIZE);
+
+  if (type_ == enterprise_management::DeviceRegisterRequest::DEVICE) {
+    UMA_HISTOGRAM_ENUMERATION(
+        kMetricDevicePolicyInvalidations,
+        GetInvalidationMetric(payload.empty(), is_expired),
+        POLICY_INVALIDATION_TYPE_SIZE);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION(
+        kMetricUserPolicyInvalidations,
+        GetInvalidationMetric(payload.empty(), is_expired),
+        POLICY_INVALIDATION_TYPE_SIZE);
+  }
   if (is_expired) {
     invalidation.Acknowledge();
     return;
   }
 
   // Update invalidation state.
   invalid_ = true;
   invalidation_.reset(new syncer::Invalidation(invalidation));
   invalidation_version_ = version;
 
@@ skipping 190 matching lines @@
 bool CloudPolicyInvalidator::GetInvalidationsEnabled() {
   if (!invalidations_enabled_)
     return false;
   // If invalidations have been enabled for less than the grace period, then
   // consider invalidations to be disabled for metrics reporting.
   base::TimeDelta elapsed = clock_->Now() - invalidations_enabled_time_;
   return elapsed.InSeconds() >= kInvalidationGracePeriod;
 }
 
 }  // namespace policy