UMA metrics for cloud policies.

chrome/browser/policy/device_policy_cache.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/device_policy_cache.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/task.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros_settings_names.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/signed_settings_helper.h"
 #include "chrome/browser/chromeos/user_cros_settings_provider.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/device_policy_identity_strategy.h"
 #include "chrome/browser/policy/enterprise_install_attributes.h"
+#include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "content/browser/browser_thread.h"
 #include "policy/configuration_policy_type.h"
 
 namespace {
 
 // Stores policy, updates the owner key if required and reports the status
@@ skipping 73 matching lines @@
     return NULL;
   }
 
   return Value::CreateIntegerValue(static_cast<int>(value));
 }
 
 }  // namespace
 
 namespace policy {
 
+namespace em = enterprise_management;
+
 DevicePolicyCache::DevicePolicyCache(
     DevicePolicyIdentityStrategy* identity_strategy,
     EnterpriseInstallAttributes* install_attributes)
     : identity_strategy_(identity_strategy),
       install_attributes_(install_attributes),
       signed_settings_helper_(chromeos::SignedSettingsHelper::Get()),
       starting_up_(true),
       ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
 }
 
 DevicePolicyCache::DevicePolicyCache(
     DevicePolicyIdentityStrategy* identity_strategy,
     EnterpriseInstallAttributes* install_attributes,
     chromeos::SignedSettingsHelper* signed_settings_helper)
     : identity_strategy_(identity_strategy),
       install_attributes_(install_attributes),
       signed_settings_helper_(signed_settings_helper),
       starting_up_(true),
       ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
 }
 
 DevicePolicyCache::~DevicePolicyCache() {
   signed_settings_helper_->CancelCallback(this);
 }
 
 void DevicePolicyCache::Load() {
+  em::LogPolicyOperation(em::kPolicyLoadRequested);
   signed_settings_helper_->StartRetrievePolicyOp(this);
 }
 
 void DevicePolicyCache::SetPolicy(const em::PolicyFetchResponse& policy) {
   DCHECK(!starting_up_);
 
   // Make sure we have an enterprise device.
   std::string registration_user(install_attributes_->GetRegistrationUser());
   if (registration_user.empty()) {
     LOG(WARNING) << "Refusing to accept policy on non-enterprise device.";
+    em::LogPolicyOperation(em::kPolicyFetchNonEnterpriseDevice);
     InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                    CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     return;
   }
 
   // Check the user this policy is for against the device-locked name.
   em::PolicyData policy_data;
   if (!policy_data.ParseFromString(policy.policy_data())) {
     LOG(WARNING) << "Invalid policy protobuf";
+    em::LogPolicyOperation(em::kPolicyFetchInvalidPolicy);
     InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                    CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     return;
   }
 
   if (registration_user != policy_data.username()) {
     LOG(WARNING) << "Refusing policy blob for " << policy_data.username()
                  << " which doesn't match " << registration_user;
+    em::LogPolicyOperation(em::kPolicyFetchUserMismatch);
     InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                    CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     return;
   }
 
   set_last_policy_refresh_time(base::Time::NowFromSystemTime());
 
   // Start a store operation.
+  em::LogPolicyOperation(em::kPolicyStoreRequested);
   new StorePolicyOperation(signed_settings_helper_,
                            policy,
                            callback_factory_.NewCallback(
                                &DevicePolicyCache::PolicyStoreOpCompleted));
 }
 
 void DevicePolicyCache::SetUnmanaged() {
   LOG(WARNING) << "Tried to set DevicePolicyCache to 'unmanaged'!";
   // This is not supported for DevicePolicyCache.
 }
 
 void DevicePolicyCache::OnRetrievePolicyCompleted(
     chromeos::SignedSettings::ReturnCode code,
     const em::PolicyFetchResponse& policy) {
   DCHECK(CalledOnValidThread());
   if (starting_up_) {
     starting_up_ = false;
     if (code == chromeos::SignedSettings::NOT_FOUND ||
         code == chromeos::SignedSettings::KEY_UNAVAILABLE ||
         !policy.has_policy_data()) {
       InformNotifier(CloudPolicySubsystem::UNENROLLED,
                      CloudPolicySubsystem::NO_DETAILS);
       return;
     }
     em::PolicyData policy_data;
     if (!policy_data.ParseFromString(policy.policy_data())) {
       LOG(WARNING) << "Failed to parse PolicyData protobuf.";
+      em::LogPolicyOperation(em::kPolicyLoadFailed);
       InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                      CloudPolicySubsystem::POLICY_LOCAL_ERROR);
       return;
     }
     if (!policy_data.has_request_token() ||
         policy_data.request_token().empty()) {
       SetUnmanagedInternal(base::Time::NowFromSystemTime());
       InformNotifier(CloudPolicySubsystem::UNMANAGED,
                      CloudPolicySubsystem::NO_DETAILS);
       // TODO(jkummerow): Reminder: When we want to feed device-wide settings
       // made by a local owner into this cache, we need to call
       // SetPolicyInternal() here.
       return;
     }
     if (!policy_data.has_username() || !policy_data.has_device_id()) {
+      em::LogPolicyOperation(em::kPolicyLoadFailed);
       InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                      CloudPolicySubsystem::POLICY_LOCAL_ERROR);
       return;
     }
     identity_strategy_->SetDeviceManagementCredentials(
         policy_data.username(),
         policy_data.device_id(),
         policy_data.request_token());
     SetPolicyInternal(policy, NULL, false);
   } else {  // In other words, starting_up_ == false.
     if (code != chromeos::SignedSettings::SUCCESS) {
       if (code == chromeos::SignedSettings::BAD_SIGNATURE) {
+        em::LogPolicyOperation(em::kPolicyFetchBadSignature);
         InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                        CloudPolicySubsystem::SIGNATURE_MISMATCH);
       } else {
+        em::LogPolicyOperation(em::kPolicyFetchOtherFailed);
         InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                        CloudPolicySubsystem::POLICY_LOCAL_ERROR);
       }
       return;
     }
-    SetPolicyInternal(policy, NULL, false);
+    bool ok = SetPolicyInternal(policy, NULL, false);
+    if (ok) {
+      em::LogPolicyOperation(em::kPolicyFetchOK);
+    }
   }
 }
 
 bool DevicePolicyCache::DecodePolicyData(const em::PolicyData& policy_data,
                                          PolicyMap* mandatory,
                                          PolicyMap* recommended) {
   em::ChromeDeviceSettingsProto policy;
   if (!policy.ParseFromString(policy_data.policy_value())) {
     LOG(WARNING) << "Failed to parse ChromeDeviceSettingsProto.";
+    em::LogPolicyOperation(em::kPolicyFetchInvalidPolicy);

[kmixter1, 2011/06/28 01:06:02]

Is there a user policy equivalent to this or are user policies not sent as
protobufs to be parsed?

[Joao da Silva, 2011/06/30 12:57:00]

There is an equivalent. Actually both invalid user policies and invalid device
policies are handled in cloud_policy_cache_base, which checks the return value
of DecodePolicyData(). This call here would actually log the same error twice,
and has been removed.

     return false;
   }
   DecodeDevicePolicy(policy, mandatory, recommended);
   return true;
 }
 
 void DevicePolicyCache::PolicyStoreOpCompleted(
     chromeos::SignedSettings::ReturnCode code) {
   DCHECK(CalledOnValidThread());
   if (code != chromeos::SignedSettings::SUCCESS) {
+    em::LogPolicyOperation(em::kPolicyStoreFailed);
     if (code == chromeos::SignedSettings::BAD_SIGNATURE) {
+      em::LogPolicyOperation(em::kPolicyFetchBadSignature);
       InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                      CloudPolicySubsystem::SIGNATURE_MISMATCH);
     } else {
+      em::LogPolicyOperation(em::kPolicyFetchOtherFailed);
       InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                      CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     }
     return;
   }
   signed_settings_helper_->StartRetrievePolicyOp(this);
 }
 
 // static
 void DevicePolicyCache::DecodeDevicePolicy(
@@ skipping 26 matching lines @@
                        Value::CreateStringValue(container.proxy_pac_url()));
     }
     if (container.has_proxy_bypass_list()) {
       recommended->Set(kPolicyProxyBypassList,
                        Value::CreateStringValue(container.proxy_bypass_list()));
     }
   }
 }
 
 }  // namespace policy