UMA metrics for cloud policies.

chrome/browser/policy/cloud_policy_cache_base.cc

 // Copyright (c) 2011 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_policy_cache_base.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
+#include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/policy_notifier.h"
 
 namespace policy {
 
+namespace em = enterprise_management;
+
 // A thin ConfigurationPolicyProvider implementation sitting on top of
 // CloudPolicyCacheBase for hooking up with ConfigurationPolicyPrefStore.
 class CloudPolicyCacheBase::CloudPolicyProvider
     : public ConfigurationPolicyProvider {
  public:
   CloudPolicyProvider(const PolicyDefinitionList* policy_list,
                       CloudPolicyCacheBase* cache,
                       CloudPolicyCacheBase::PolicyLevel level)
       : ConfigurationPolicyProvider(policy_list),
         cache_(cache),
@@ skipping 65 matching lines @@
   bool initialization_was_not_complete = !initialization_complete_;
   is_unmanaged_ = false;
   PolicyMap mandatory_policy;
   PolicyMap recommended_policy;
   base::Time temp_timestamp;
   PublicKeyVersion temp_public_key_version;
   bool ok = DecodePolicyResponse(policy, &mandatory_policy, &recommended_policy,
                                  &temp_timestamp, &temp_public_key_version);
   if (!ok) {
     LOG(WARNING) << "Decoding policy data failed.";
+    em::LogPolicyOperation(em::kPolicyFetchInvalidPolicy);
     return false;
   }
   if (timestamp) {
     *timestamp = temp_timestamp;
   }
   if (check_for_timestamp_validity &&
       temp_timestamp > base::Time::NowFromSystemTime()) {
     LOG(WARNING) << "Rejected policy data, file is from the future.";
+    em::LogPolicyOperation(em::kPolicyFetchTimestampInFuture);
     return false;
   }
   public_key_version_.version = temp_public_key_version.version;
   public_key_version_.valid = temp_public_key_version.valid;
 
   const bool new_policy_differs =
       !mandatory_policy_.Equals(mandatory_policy) ||
       !recommended_policy_.Equals(recommended_policy);
   mandatory_policy_.Swap(&mandatory_policy);
   recommended_policy_.Swap(&recommended_policy);
   initialization_complete_ = true;
 
+  if (!new_policy_differs) {
+    em::LogPolicyOperation(em::kPolicyFetchNotModified);
+  }
+
   if (new_policy_differs || initialization_was_not_complete) {
     FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
                       observer_list_, OnUpdatePolicy());
   }
   InformNotifier(CloudPolicySubsystem::SUCCESS,
                  CloudPolicySubsystem::NO_DETAILS);
   return true;
 }
 
 void CloudPolicyCacheBase::SetUnmanagedInternal(const base::Time& timestamp) {
@@ skipping 47 matching lines @@
 void CloudPolicyCacheBase::InformNotifier(
     CloudPolicySubsystem::PolicySubsystemState state,
     CloudPolicySubsystem::ErrorDetails error_details) {
   // TODO(jkummerow): To obsolete this NULL-check, make all uses of
   // UserPolicyCache explicitly set a notifier using |set_policy_notifier()|.
   if (notifier_)
     notifier_->Inform(state, error_details, PolicyNotifier::POLICY_CACHE);
 }
 
 }  // namespace policy