UMA metrics for cloud policies.

BUG=chromium-os:14002
TEST=Set cloud policies using testserver, corrupt some files, check about:histograms


Review URL: http://codereview.chromium.org/7105018

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@91857 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 311 insertions, 3 deletions

diff --git a/chrome/browser/policy/cloud_policy_cache_base.cc b/chrome/browser/policy/cloud_policy_cache_base.cc
index c39fe94..8d23415 100644
--- a/chrome/browser/policy/cloud_policy_cache_base.cc
+++ b/chrome/browser/policy/cloud_policy_cache_base.cc
@@ -7,7 +7,9 @@
 #include <string>
 
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/values.h"
+#include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/policy_notifier.h"
 
 namespace policy {
@@ -65,6 +67,8 @@ bool CloudPolicyCacheBase::SetPolicyInternal(
                                  &temp_timestamp, &temp_public_key_version);
   if (!ok) {
     LOG(WARNING) << "Decoding policy data failed.";
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchInvalidPolicy,
+                              kMetricPolicySize);
     return false;
   }
   if (timestamp) {
@@ -73,6 +77,9 @@ bool CloudPolicyCacheBase::SetPolicyInternal(
   if (check_for_timestamp_validity &&
       temp_timestamp > base::Time::NowFromSystemTime()) {
     LOG(WARNING) << "Rejected policy data, file is from the future.";
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy,
+                              kMetricPolicyFetchTimestampInFuture,
+                              kMetricPolicySize);
     return false;
   }
   public_key_version_.version = temp_public_key_version.version;
@@ -85,6 +92,11 @@ bool CloudPolicyCacheBase::SetPolicyInternal(
   recommended_policy_.Swap(&recommended_policy);
   initialization_complete_ = true;
 
+  if (!new_policy_differs) {
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchNotModified,
+                              kMetricPolicySize);
+  }
+
   if (new_policy_differs || initialization_was_not_complete) {
     FOR_EACH_OBSERVER(Observer, observer_list_, OnCacheUpdate(this));
   }
diff --git a/chrome/browser/policy/cloud_policy_controller.cc b/chrome/browser/policy/cloud_policy_controller.cc
index 8c3ba08..daef15d 100644
--- a/chrome/browser/policy/cloud_policy_controller.cc
+++ b/chrome/browser/policy/cloud_policy_controller.cc
@@ -10,12 +10,14 @@
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/policy/cloud_policy_cache_base.h"
 #include "chrome/browser/policy/cloud_policy_subsystem.h"
 #include "chrome/browser/policy/device_management_backend.h"
 #include "chrome/browser/policy/device_management_service.h"
+#include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
 
 // Domain names that are known not to be managed.
@@ -112,8 +114,13 @@ void CloudPolicyController::HandlePolicyResponse(
       cache_->SetPolicy(response.response(0));
       SetState(STATE_POLICY_VALID);
     } else {
+      UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchBadResponse,
+                                kMetricPolicySize);
       SetState(STATE_POLICY_UNAVAILABLE);
     }
+  } else {
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchBadResponse,
+                              kMetricPolicySize);
   }
 }
 
diff --git a/chrome/browser/policy/device_management_backend_impl.cc b/chrome/browser/policy/device_management_backend_impl.cc
index 72cf087..7f3850e 100644
--- a/chrome/browser/policy/device_management_backend_impl.cc
+++ b/chrome/browser/policy/device_management_backend_impl.cc
@@ -11,9 +11,11 @@
 #include <sys/utsname.h>
 #endif
 
+#include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "chrome/browser/policy/device_management_service.h"
+#include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/common/chrome_version_info.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_status.h"
@@ -302,9 +304,28 @@ class DeviceManagementRegisterJob : public DeviceManagementJobBase {
  private:
   // DeviceManagementJobBase overrides.
   virtual void OnError(DeviceManagementBackend::ErrorCode error) {
+    MetricToken sample;
+    switch (error) {
+      case DeviceManagementBackend::kErrorRequestInvalid:
+      case DeviceManagementBackend::kErrorRequestFailed:
+        sample = kMetricTokenFetchRequestFailed;
+        break;
+      case DeviceManagementBackend::kErrorServiceDeviceNotFound:
+        sample = kMetricTokenFetchDeviceNotFound;
+        break;
+      case DeviceManagementBackend::kErrorServiceManagementNotSupported:
+        sample = kMetricTokenFetchManagementNotSupported;
+        break;
+      default:
+        sample = kMetricTokenFetchServerFailed;
+        break;
+    }
+    UMA_HISTOGRAM_ENUMERATION(kMetricToken, sample, kMetricTokenSize);
     delegate_->OnError(error);
   }
   virtual void OnResponse(const em::DeviceManagementResponse& response) {
+    UMA_HISTOGRAM_ENUMERATION(kMetricToken, kMetricTokenFetchResponseReceived,
+                              kMetricTokenSize);
     delegate_->HandleRegisterResponse(response.register_response());
   }
 
@@ -372,9 +393,28 @@ class DeviceManagementPolicyJob : public DeviceManagementJobBase {
  private:
   // DeviceManagementJobBase overrides.
   virtual void OnError(DeviceManagementBackend::ErrorCode error) {
+    MetricPolicy sample;
+    switch (error) {
+      case DeviceManagementBackend::kErrorRequestInvalid:
+      case DeviceManagementBackend::kErrorRequestFailed:
+        sample = kMetricPolicyFetchRequestFailed;
+        break;
+      case DeviceManagementBackend::kErrorServicePolicyNotFound:
+        sample = kMetricPolicyFetchNotFound;
+        break;
+      case DeviceManagementBackend::kErrorServiceManagementTokenInvalid:
+        sample = kMetricPolicyFetchInvalidToken;
+        break;
+      default:
+        sample = kMetricPolicyFetchServerFailed;
+        break;
+    }
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, sample, kMetricPolicySize);
     delegate_->OnError(error);
   }
   virtual void OnResponse(const em::DeviceManagementResponse& response) {
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchResponseReceived,
+                              kMetricPolicySize);
     delegate_->HandlePolicyResponse(response.policy_response());
   }
 
@@ -467,6 +507,8 @@ void DeviceManagementBackendImpl::ProcessRegisterRequest(
     const std::string& device_id,
     const em::DeviceRegisterRequest& request,
     DeviceRegisterResponseDelegate* delegate) {
+  UMA_HISTOGRAM_ENUMERATION(kMetricToken, kMetricTokenFetchRequested,
+                            kMetricTokenSize);
   AddJob(new DeviceManagementRegisterJob(this, auth_token, device_id, request,
                                          delegate));
 }
@@ -485,6 +527,8 @@ void DeviceManagementBackendImpl::ProcessPolicyRequest(
     const std::string& device_id,
     const em::DevicePolicyRequest& request,
     DevicePolicyResponseDelegate* delegate) {
+  UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchRequested,
+                            kMetricPolicySize);
   AddJob(new DeviceManagementPolicyJob(this, device_management_token, device_id,
                                        request, delegate));
 }
diff --git a/chrome/browser/policy/device_policy_cache.cc b/chrome/browser/policy/device_policy_cache.cc
index f972779..6f068bc 100644
--- a/chrome/browser/policy/device_policy_cache.cc
+++ b/chrome/browser/policy/device_policy_cache.cc
@@ -7,6 +7,7 @@
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/task.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
@@ -17,6 +18,7 @@
 #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"
@@ -146,6 +148,9 @@ void DevicePolicyCache::SetPolicy(const em::PolicyFetchResponse& policy) {
   std::string registration_user(install_attributes_->GetRegistrationUser());
   if (registration_user.empty()) {
     LOG(WARNING) << "Refusing to accept policy on non-enterprise device.";
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy,
+                              kMetricPolicyFetchNonEnterpriseDevice,
+                              kMetricPolicySize);
     InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                    CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     return;
@@ -155,6 +160,8 @@ void DevicePolicyCache::SetPolicy(const em::PolicyFetchResponse& policy) {
   em::PolicyData policy_data;
   if (!policy_data.ParseFromString(policy.policy_data())) {
     LOG(WARNING) << "Invalid policy protobuf";
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchInvalidPolicy,
+                              kMetricPolicySize);
     InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                    CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     return;
@@ -163,6 +170,8 @@ void DevicePolicyCache::SetPolicy(const em::PolicyFetchResponse& policy) {
   if (registration_user != policy_data.username()) {
     LOG(WARNING) << "Refusing policy blob for " << policy_data.username()
                  << " which doesn't match " << registration_user;
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchUserMismatch,
+                              kMetricPolicySize);
     InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                    CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     return;
@@ -202,6 +211,8 @@ void DevicePolicyCache::OnRetrievePolicyCompleted(
     em::PolicyData policy_data;
     if (!policy_data.ParseFromString(policy.policy_data())) {
       LOG(WARNING) << "Failed to parse PolicyData protobuf.";
+      UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyLoadFailed,
+                                kMetricPolicySize);
       InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                      CloudPolicySubsystem::POLICY_LOCAL_ERROR);
       return;
@@ -217,10 +228,14 @@ void DevicePolicyCache::OnRetrievePolicyCompleted(
       return;
     }
     if (!policy_data.has_username() || !policy_data.has_device_id()) {
+      UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyLoadFailed,
+                                kMetricPolicySize);
       InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                      CloudPolicySubsystem::POLICY_LOCAL_ERROR);
       return;
     }
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyLoadSucceeded,
+                              kMetricPolicySize);
     identity_strategy_->SetDeviceManagementCredentials(
         policy_data.username(),
         policy_data.device_id(),
@@ -229,15 +244,23 @@ void DevicePolicyCache::OnRetrievePolicyCompleted(
   } else {  // In other words, starting_up_ == false.
     if (code != chromeos::SignedSettings::SUCCESS) {
       if (code == chromeos::SignedSettings::BAD_SIGNATURE) {
+        UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchBadSignature,
+                                  kMetricPolicySize);
         InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                        CloudPolicySubsystem::SIGNATURE_MISMATCH);
       } else {
+        UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchOtherFailed,
+                                  kMetricPolicySize);
         InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                        CloudPolicySubsystem::POLICY_LOCAL_ERROR);
       }
       return;
     }
-    SetPolicyInternal(policy, NULL, false);
+    bool ok = SetPolicyInternal(policy, NULL, false);
+    if (ok) {
+      UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchOK,
+                                kMetricPolicySize);
+    }
   }
 }
 
@@ -257,15 +280,23 @@ void DevicePolicyCache::PolicyStoreOpCompleted(
     chromeos::SignedSettings::ReturnCode code) {
   DCHECK(CalledOnValidThread());
   if (code != chromeos::SignedSettings::SUCCESS) {
+    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyStoreFailed,
+                              kMetricPolicySize);
     if (code == chromeos::SignedSettings::BAD_SIGNATURE) {
+      UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchBadSignature,
+                                kMetricPolicySize);
       InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                      CloudPolicySubsystem::SIGNATURE_MISMATCH);
     } else {
+      UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchOtherFailed,
+                                kMetricPolicySize);
       InformNotifier(CloudPolicySubsystem::LOCAL_ERROR,
                      CloudPolicySubsystem::POLICY_LOCAL_ERROR);
     }
     return;
   }
+  UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyStoreSucceeded,
+                            kMetricPolicySize);
   signed_settings_helper_->StartRetrievePolicyOp(this);
 }
 
diff --git a/chrome/browser/policy/device_token_fetcher.cc b/chrome/browser/policy/device_token_fetcher.cc
index d418b34..fe9cbb2 100644
--- a/chrome/browser/policy/device_token_fetcher.cc
+++ b/chrome/browser/policy/device_token_fetcher.cc
@@ -9,8 +9,10 @@
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
+#include "base/metrics/histogram.h"
 #include "chrome/browser/policy/cloud_policy_cache_base.h"
 #include "chrome/browser/policy/device_management_service.h"
+#include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 
@@ -119,10 +121,14 @@ void DeviceTokenFetcher::RemoveObserver(
 void DeviceTokenFetcher::HandleRegisterResponse(
     const em::DeviceRegisterResponse& response) {
   if (response.has_device_management_token()) {
+    UMA_HISTOGRAM_ENUMERATION(kMetricToken, kMetricTokenFetchOK,
+                              kMetricTokenSize);
     device_token_ = response.device_management_token();
     SetState(STATE_TOKEN_AVAILABLE);
   } else {
     NOTREACHED();
+    UMA_HISTOGRAM_ENUMERATION(kMetricToken, kMetricTokenFetchBadResponse,
+                              kMetricTokenSize);
     SetState(STATE_ERROR);
   }
 }
diff --git a/chrome/browser/policy/enterprise_metrics.cc b/chrome/browser/policy/enterprise_metrics.cc
new file mode 100644
index 0000000..db253a1
--- /dev/null
+++ b/chrome/browser/policy/enterprise_metrics.cc
@@ -0,0 +1,13 @@
+// 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/enterprise_metrics.h"
+
+namespace policy {
+
+const char* kMetricToken = "Enterprise.DMToken";
+const char* kMetricPolicy = "Enterprise.Policy";
+const char* kMetricEnrollment = "Enterprise.Enrollment";
+
+}  // namespace policy
diff --git a/chrome/browser/policy/enterprise_metrics.h b/chrome/browser/policy/enterprise_metrics.h
new file mode 100644
index 0000000..480b36c
--- /dev/null
+++ b/chrome/browser/policy/enterprise_metrics.h
@@ -0,0 +1,133 @@
+// 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.
+
+#ifndef CHROME_BROWSER_POLICY_ENTERPRISE_METRICS_H_
+#define CHROME_BROWSER_POLICY_ENTERPRISE_METRICS_H_
+#pragma once
+
+namespace policy {
+
+// Metrics collected for enterprise events.
+
+// Events related to fetching, saving and loading DM server tokens.
+// These metrics are collected both for device and user tokens.
+enum MetricToken {
+  // A cached token was successfully loaded from disk.
+  kMetricTokenLoadSucceeded = 0,
+  // Reading a cached token from disk failed.
+  kMetricTokenLoadFailed,
+
+  // A token fetch request was sent to the DM server.
+  kMetricTokenFetchRequested,
+  // The request was invalid, or the HTTP request failed.
+  kMetricTokenFetchRequestFailed,
+  // Error HTTP status received, or the DM server failed in another way.
+  kMetricTokenFetchServerFailed,
+  // A response to the fetch request was received.
+  kMetricTokenFetchResponseReceived,
+  // The response received was invalid. This happens when some expected data
+  // was not present in the response.
+  kMetricTokenFetchBadResponse,
+  // DM server reported that management is not supported.
+  kMetricTokenFetchManagementNotSupported,
+  // DM server reported that the given device ID was not found.
+  kMetricTokenFetchDeviceNotFound,
+  // DM token successfully retrieved.
+  kMetricTokenFetchOK,
+
+  // Successfully cached a token to disk.
+  kMetricTokenStoreSucceeded,
+  // Caching a token to disk failed.
+  kMetricTokenStoreFailed,
+
+  kMetricTokenSize  // Must be the last.
+};
+
+// Events related to fetching, saving and loading user and device policies.
+enum MetricPolicy {
+  // A cached policy was successfully loaded from disk.
+  kMetricPolicyLoadSucceeded = 0,
+  // Reading a cached policy from disk failed.
+  kMetricPolicyLoadFailed,
+
+  // A policy fetch request was sent to the DM server.
+  kMetricPolicyFetchRequested,
+  // The request was invalid, or the HTTP request failed.
+  kMetricPolicyFetchRequestFailed,
+  // Error HTTP status received, or the DM server failed in another way.
+  kMetricPolicyFetchServerFailed,
+  // Policy not found for the given user or device.
+  kMetricPolicyFetchNotFound,
+  // DM server didn't accept the token used in the request.
+  kMetricPolicyFetchInvalidToken,
+  // A response to the policy fetch request was received.
+  kMetricPolicyFetchResponseReceived,
+  // The policy response message didn't contain a policy, or other data was
+  // missing.
+  kMetricPolicyFetchBadResponse,
+  // Failed to decode the policy.
+  kMetricPolicyFetchInvalidPolicy,
+  // The device policy was rejected because its signature was invalid.
+  kMetricPolicyFetchBadSignature,
+  // Rejected policy because its timestamp is in the future.
+  kMetricPolicyFetchTimestampInFuture,
+  // Device policy rejected because the device is not managed.
+  kMetricPolicyFetchNonEnterpriseDevice,
+  // The policy was provided for a username that is different from the device
+  // owner, and the policy was rejected.
+  kMetricPolicyFetchUserMismatch,
+  // The policy was rejected for another reason. Currently this can happen
+  // only for device policies, when the SignedSettings fail to store or retrieve
+  // a stored policy.
+  kMetricPolicyFetchOtherFailed,
+  // The fetched policy was accepted.
+  kMetricPolicyFetchOK,
+  // The policy just fetched didn't have any changes compared to the cached
+  // policy.
+  kMetricPolicyFetchNotModified,
+
+  // Successfully cached a policy to disk.
+  kMetricPolicyStoreSucceeded,
+  // Caching a policy to disk failed.
+  kMetricPolicyStoreFailed,
+
+  kMetricPolicySize  // Must be the last.
+};
+
+// Events related to device enrollment.
+enum MetricEnrollment {
+  // The enrollment screen was closed without completing the enrollment
+  // process.
+  kMetricEnrollmentCancelled = 0,
+  // The user submitted credentials and started the enrollment process.
+  kMetricEnrollmentStarted,
+  // Enrollment failed due to a network error.
+  kMetricEnrollmentNetworkFailed,
+  // Enrollment failed because logging in to Gaia failed.
+  kMetricEnrollmentLoginFailed,
+  // Enrollment failed because it is not supported for the account used.
+  kMetricEnrollmentNotSupported,
+  // Enrollment failed because it failed to apply device policy.
+  kMetricEnrollmentPolicyFailed,
+  // Enrollment failed due to an unexpected error. This currently happens when
+  // the Gaia auth token is not issued for the DM service, the device cloud
+  // policy subsystem isn't initialized, or when fetching Gaia tokens fails
+  // for an unknown reason.
+  kMetricEnrollmentOtherFailed,
+  // Enrollment was successful.
+  kMetricEnrollmentOK,
+
+  kMetricEnrollmentSize  // Must be the last.
+};
+
+// Names for the UMA counters. They are shared from here since the events
+// from the same enum above can be triggered in different files, and must use
+// the same UMA histogram name.
+extern const char* kMetricToken;
+extern const char* kMetricPolicy;
+extern const char* kMetricEnrollment;
+
+}  // namespace policy
+
+#endif  // CHROME_BROWSER_POLICY_ENTERPRISE_METRICS_H_
diff --git a/chrome/browser/policy/user_policy_cache.cc b/chrome/browser/policy/user_policy_cache.cc
index 4ed00cc..838757b 100644
--- a/chrome/browser/policy/user_policy_cache.cc
+++ b/chrome/browser/policy/user_policy_cache.cc
@@ -9,10 +9,12 @@
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/cloud_policy_provider.h"
+#include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/proto/cloud_policy.pb.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
@@ -47,6 +49,8 @@ void UserPolicyCache::SetPolicy(const em::PolicyFetchResponse& policy) {
   base::Time timestamp;
   if (!SetPolicyInternal(policy, &timestamp, false))
     return;
+  UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchOK,
+                            kMetricPolicySize);
 
   if (timestamp > base::Time::NowFromSystemTime() +
                   base::TimeDelta::FromMinutes(1)) {
diff --git a/chrome/browser/policy/user_policy_disk_cache.cc b/chrome/browser/policy/user_policy_disk_cache.cc
index 08c2ba7..05eede31 100644
--- a/chrome/browser/policy/user_policy_disk_cache.cc
+++ b/chrome/browser/policy/user_policy_disk_cache.cc
@@ -4,11 +4,31 @@
 
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/task.h"
+#include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "chrome/browser/policy/user_policy_disk_cache.h"
 #include "content/browser/browser_thread.h"
 
+namespace {
+
+// Other places can sample on the same UMA counter, so make sure they all do
+// it on the same thread (UI).
+void SampleUMAOnUIThread(policy::MetricPolicy sample) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  UMA_HISTOGRAM_ENUMERATION(policy::kMetricPolicy, sample,
+                            policy::kMetricPolicySize);
+}
+
+void SampleUMA(policy::MetricPolicy sample) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          NewRunnableFunction(&SampleUMAOnUIThread, sample));
+}
+
+}  // namespace
+
 namespace policy {
 
 UserPolicyDiskCache::Delegate::~Delegate() {}
@@ -46,6 +66,7 @@ void UserPolicyDiskCache::LoadOnFileThread() {
   if (!file_util::ReadFileToString(backing_file_path_, &data)) {
     LOG(WARNING) << "Failed to read policy data from "
                  << backing_file_path_.value();
+    SampleUMA(kMetricPolicyLoadFailed);
     return;
   }
 
@@ -54,6 +75,7 @@ void UserPolicyDiskCache::LoadOnFileThread() {
   if (!cached_response.ParseFromArray(data.c_str(), data.size())) {
     LOG(WARNING) << "Failed to parse policy data read from "
                  << backing_file_path_.value();
+    SampleUMA(kMetricPolicyLoadFailed);
     return;
   }
 
@@ -67,31 +89,36 @@ void UserPolicyDiskCache::LoadOnFileThread() {
 void UserPolicyDiskCache::FinishLoadOnUIThread(
     const em::CachedCloudPolicyResponse& policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyLoadSucceeded,
+                            kMetricPolicySize);
   if (delegate_.get())
     delegate_->OnDiskCacheLoaded(policy);
 }
 
-
 void UserPolicyDiskCache::StoreOnFileThread(
     const em::CachedCloudPolicyResponse& policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   std::string data;
   if (!policy.SerializeToString(&data)) {
     LOG(WARNING) << "Failed to serialize policy data";
+    SampleUMA(kMetricPolicyStoreFailed);
     return;
   }
 
   if (!file_util::CreateDirectory(backing_file_path_.DirName())) {
     LOG(WARNING) << "Failed to create directory "
                  << backing_file_path_.DirName().value();
+    SampleUMA(kMetricPolicyStoreFailed);
     return;
   }
 
   int size = data.size();
   if (file_util::WriteFile(backing_file_path_, data.c_str(), size) != size) {
     LOG(WARNING) << "Failed to write " << backing_file_path_.value();
+    SampleUMA(kMetricPolicyStoreFailed);
     return;
   }
+  SampleUMA(kMetricPolicyStoreSucceeded);
 }
 
 }  // namespace policy
diff --git a/chrome/browser/policy/user_policy_token_cache.cc b/chrome/browser/policy/user_policy_token_cache.cc
index adba4a4..e2341d8 100644
--- a/chrome/browser/policy/user_policy_token_cache.cc
+++ b/chrome/browser/policy/user_policy_token_cache.cc
@@ -5,8 +5,28 @@
 #include "chrome/browser/policy/user_policy_token_cache.h"
 
 #include "base/file_util.h"
+#include "base/metrics/histogram.h"
+#include "chrome/browser/policy/enterprise_metrics.h"
 #include "content/browser/browser_thread.h"
 
+namespace {
+
+// Other places can sample on the same UMA counter, so make sure they all do
+// it on the same thread (UI).
+void SampleUMAOnUIThread(policy::MetricToken sample) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  UMA_HISTOGRAM_ENUMERATION(policy::kMetricToken, sample,
+                            policy::kMetricTokenSize);
+}
+
+void SampleUMA(policy::MetricToken sample) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          NewRunnableFunction(&SampleUMAOnUIThread, sample));
+}
+
+}  // namespace
+
 namespace policy {
 
 namespace em = enterprise_management;
@@ -52,6 +72,9 @@ void UserPolicyTokenCache::LoadOnFileThread() {
         device_credentials.ParseFromArray(data.c_str(), data.size())) {
       device_token = device_credentials.device_token();
       device_id = device_credentials.device_id();
+      SampleUMA(kMetricTokenLoadSucceeded);
+    } else {
+      SampleUMA(kMetricTokenLoadFailed);
     }
   }
 
@@ -81,16 +104,24 @@ void UserPolicyTokenCache::StoreOnFileThread(const std::string& token,
   if (!success) {
     LOG(WARNING) << "Failed serialize device token data, will not write "
                  << cache_file_.value();
+    SampleUMA(kMetricTokenStoreFailed);
     return;
   }
 
   if (!file_util::CreateDirectory(cache_file_.DirName())) {
     LOG(WARNING) << "Failed to create directory "
                  << cache_file_.DirName().value();
+    SampleUMA(kMetricTokenStoreFailed);
     return;
   }
 
-  file_util::WriteFile(cache_file_, data.c_str(), data.length());
+  int size = data.size();
+  if (file_util::WriteFile(cache_file_, data.c_str(), size) != size) {
+    LOG(WARNING) << "Failed to write " << cache_file_.value();
+    SampleUMA(kMetricTokenStoreFailed);
+  }
+
+  SampleUMA(kMetricTokenStoreSucceeded);
 }
 
 }  // namespace policy