UMA metrics for cloud policies.

chrome/browser/policy/device_management_backend_impl.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_management_backend_impl.h"
 
 #include <utility>
 #include <vector>
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 #include <sys/utsname.h>
 #endif
 
 #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"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/system_access.h"
 #endif
 
 namespace policy {
 
+namespace em = enterprise_management;
+
 // Name constants for URL query parameters.
 const char DeviceManagementBackendImpl::kParamRequest[] = "request";
 const char DeviceManagementBackendImpl::kParamDeviceType[] = "devicetype";
 const char DeviceManagementBackendImpl::kParamAppType[] = "apptype";
 const char DeviceManagementBackendImpl::kParamDeviceID[] = "deviceid";
 const char DeviceManagementBackendImpl::kParamAgent[] = "agent";
 const char DeviceManagementBackendImpl::kParamPlatform[] = "platform";
 
 // String constants for the device and app type we report to the server.
 const char DeviceManagementBackendImpl::kValueRequestRegister[] = "register";
@@ skipping 258 matching lines @@
     SetAuthToken(auth_token);
     em::DeviceManagementRequest request_wrapper;
     request_wrapper.mutable_register_request()->CopyFrom(request);
     SetPayload(request_wrapper);
   }
   virtual ~DeviceManagementRegisterJob() {}
 
  private:
   // DeviceManagementJobBase overrides.
   virtual void OnError(DeviceManagementBackend::ErrorCode error) {
+    switch (error) {
+      case DeviceManagementBackend::kErrorRequestInvalid:
+      case DeviceManagementBackend::kErrorRequestFailed:
+        em::LogTokenOperation(em::kTokenFetchRequestFailed);
+        break;
+      case DeviceManagementBackend::kErrorServiceDeviceNotFound:
+        em::LogTokenOperation(em::kTokenFetchDeviceNotFound);
+        break;
+      case DeviceManagementBackend::kErrorServiceManagementNotSupported:
+        em::LogTokenOperation(em::kTokenFetchManagementNotSupported);
+        break;
+      default:
+        em::LogTokenOperation(em::kTokenFetchServerFailed);
+        break;
+    }
     delegate_->OnError(error);
   }
   virtual void OnResponse(const em::DeviceManagementResponse& response) {
+    em::LogTokenOperation(em::kTokenFetchResponseReceived);
     delegate_->HandleRegisterResponse(response.register_response());
   }
 
   DeviceManagementBackend::DeviceRegisterResponseDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementRegisterJob);
 };
 
 // Handles device unregistration jobs.
 class DeviceManagementUnregisterJob : public DeviceManagementJobBase {
@@ skipping 47 matching lines @@
     SetDeviceManagementToken(device_management_token);
     em::DeviceManagementRequest request_wrapper;
     request_wrapper.mutable_policy_request()->CopyFrom(request);
     SetPayload(request_wrapper);
   }
   virtual ~DeviceManagementPolicyJob() {}
 
  private:
   // DeviceManagementJobBase overrides.
   virtual void OnError(DeviceManagementBackend::ErrorCode error) {
+    switch (error) {
+      case DeviceManagementBackend::kErrorRequestInvalid:
+      case DeviceManagementBackend::kErrorRequestFailed:
+        em::LogPolicyOperation(em::kPolicyFetchRequestFailed);
+        break;
+      case DeviceManagementBackend::kErrorServicePolicyNotFound:
+        em::LogPolicyOperation(em::kPolicyFetchNotFound);
+        break;
+      case DeviceManagementBackend::kErrorServiceManagementTokenInvalid:
+        em::LogPolicyOperation(em::kPolicyFetchInvalidToken);
+        break;
+      default:
+        em::LogPolicyOperation(em::kPolicyFetchServerFailed);
+        break;
+    }
     delegate_->OnError(error);
   }
   virtual void OnResponse(const em::DeviceManagementResponse& response) {
+    em::LogPolicyOperation(em::kPolicyFetchResponseReceived);
     delegate_->HandlePolicyResponse(response.policy_response());
   }
 
   DeviceManagementBackend::DevicePolicyResponseDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementPolicyJob);
 };
 
 DeviceManagementBackendImpl::DeviceManagementBackendImpl(
     DeviceManagementService* service)
@@ skipping 72 matching lines @@
 void DeviceManagementBackendImpl::AddJob(DeviceManagementJobBase* job) {
   pending_jobs_.insert(job);
   service_->AddJob(job);
 }
 
 void DeviceManagementBackendImpl::ProcessRegisterRequest(
     const std::string& auth_token,
     const std::string& device_id,
     const em::DeviceRegisterRequest& request,
     DeviceRegisterResponseDelegate* delegate) {
+  em::LogTokenOperation(em::kTokenFetchRequested);
   AddJob(new DeviceManagementRegisterJob(this, auth_token, device_id, request,
                                          delegate));
 }
 
 void DeviceManagementBackendImpl::ProcessUnregisterRequest(
     const std::string& device_management_token,
     const std::string& device_id,
     const em::DeviceUnregisterRequest& request,
     DeviceUnregisterResponseDelegate* delegate) {
   AddJob(new DeviceManagementUnregisterJob(this, device_management_token,
                                            device_id, request, delegate));
 }
 
 void DeviceManagementBackendImpl::ProcessPolicyRequest(
     const std::string& device_management_token,
     const std::string& device_id,
     const em::DevicePolicyRequest& request,
     DevicePolicyResponseDelegate* delegate) {
+  em::LogPolicyOperation(em::kPolicyFetchRequested);
   AddJob(new DeviceManagementPolicyJob(this, device_management_token, device_id,
                                        request, delegate));
 }
 
 }  // namespace policy