New policy protobuf protocol.

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>
 
 #include "base/stringprintf.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_status.h"
 #include "chrome/browser/policy/device_management_service.h"
 #include "chrome/common/chrome_version_info.h"
 
 namespace policy {
 
 // 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";
 
 // String constants for the device and app type we report to the server.
 const char DeviceManagementBackendImpl::kValueRequestRegister[] = "register";
 const char DeviceManagementBackendImpl::kValueRequestUnregister[] =
     "unregister";
 const char DeviceManagementBackendImpl::kValueRequestPolicy[] = "policy";
+const char DeviceManagementBackendImpl::kValueRequestCloudPolicy[] =
+    "cloud_policy";
 const char DeviceManagementBackendImpl::kValueDeviceType[] = "Chrome OS";
 const char DeviceManagementBackendImpl::kValueAppType[] = "Chrome";
 
 namespace {
 
 const char kValueAgent[] = "%s enterprise management client version %s (%s)";
 
 const char kPostContentType[] = "application/protobuf";
 
 const char kServiceTokenAuthHeader[] = "Authorization: GoogleLogin auth=";
@@ skipping 183 matching lines @@
 }
 
 // Handles device registration jobs.
 class DeviceManagementRegisterJob : public DeviceManagementJobBase {
  public:
   DeviceManagementRegisterJob(
       DeviceManagementBackendImpl* backend_impl,
       const std::string& auth_token,
       const std::string& device_id,
       const em::DeviceRegisterRequest& request,
-      DeviceManagementBackend::DeviceRegisterResponseDelegate* delegate);
+      DeviceManagementBackend::DeviceRegisterResponseDelegate* delegate)
+      : DeviceManagementJobBase(
+          backend_impl,
+          DeviceManagementBackendImpl::kValueRequestRegister,
+          device_id),
+        delegate_(delegate) {
+    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) {
     delegate_->OnError(error);
   }
   virtual void OnResponse(const em::DeviceManagementResponse& response) {
     delegate_->HandleRegisterResponse(response.register_response());
   }
 
   DeviceManagementBackend::DeviceRegisterResponseDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementRegisterJob);
 };
 
-DeviceManagementRegisterJob::DeviceManagementRegisterJob(
-    DeviceManagementBackendImpl* backend_impl,
-    const std::string& auth_token,
-    const std::string& device_id,
-    const em::DeviceRegisterRequest& request,
-    DeviceManagementBackend::DeviceRegisterResponseDelegate* delegate)
-    : DeviceManagementJobBase(
-          backend_impl,
-          DeviceManagementBackendImpl::kValueRequestRegister,
-          device_id),
-      delegate_(delegate) {
-  SetAuthToken(auth_token);
-  em::DeviceManagementRequest request_wrapper;
-  request_wrapper.mutable_register_request()->CopyFrom(request);
-  SetPayload(request_wrapper);
-}
-
 // Handles device unregistration jobs.
 class DeviceManagementUnregisterJob : public DeviceManagementJobBase {
  public:
   DeviceManagementUnregisterJob(
       DeviceManagementBackendImpl* backend_impl,
       const std::string& device_id,
       const std::string& device_management_token,
       const em::DeviceUnregisterRequest& request,
-      DeviceManagementBackend::DeviceUnregisterResponseDelegate* delegate);
+      DeviceManagementBackend::DeviceUnregisterResponseDelegate* delegate)
+      : DeviceManagementJobBase(
+          backend_impl,
+          DeviceManagementBackendImpl::kValueRequestUnregister,
+          device_id),
+        delegate_(delegate) {
+    SetDeviceManagementToken(device_management_token);
+    em::DeviceManagementRequest request_wrapper;
+    request_wrapper.mutable_unregister_request()->CopyFrom(request);
+    SetPayload(request_wrapper);
+  }
   virtual ~DeviceManagementUnregisterJob() {}
 
  private:
   // DeviceManagementJobBase overrides.
   virtual void OnError(DeviceManagementBackend::ErrorCode error) {
     delegate_->OnError(error);
   }
   virtual void OnResponse(const em::DeviceManagementResponse& response) {
     delegate_->HandleUnregisterResponse(response.unregister_response());
   }
 
   DeviceManagementBackend::DeviceUnregisterResponseDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementUnregisterJob);
 };
 
-DeviceManagementUnregisterJob::DeviceManagementUnregisterJob(
-    DeviceManagementBackendImpl* backend_impl,
-    const std::string& device_management_token,
-    const std::string& device_id,
-    const em::DeviceUnregisterRequest& request,
-    DeviceManagementBackend::DeviceUnregisterResponseDelegate* delegate)
-    : DeviceManagementJobBase(
-          backend_impl,
-          DeviceManagementBackendImpl::kValueRequestUnregister,
-          device_id),
-      delegate_(delegate) {
-  SetDeviceManagementToken(device_management_token);
-  em::DeviceManagementRequest request_wrapper;
-  request_wrapper.mutable_unregister_request()->CopyFrom(request);
-  SetPayload(request_wrapper);
-}
-
 // Handles policy request jobs.
 class DeviceManagementPolicyJob : public DeviceManagementJobBase {
  public:
   DeviceManagementPolicyJob(
       DeviceManagementBackendImpl* backend_impl,
       const std::string& device_management_token,
       const std::string& device_id,
       const em::DevicePolicyRequest& request,
-      DeviceManagementBackend::DevicePolicyResponseDelegate* delegate);
+      DeviceManagementBackend::DevicePolicyResponseDelegate* delegate)
+      : DeviceManagementJobBase(
+          backend_impl,
+          DeviceManagementBackendImpl::kValueRequestPolicy,
+          device_id),
+        delegate_(delegate) {
+    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) {
     delegate_->OnError(error);
   }
   virtual void OnResponse(const em::DeviceManagementResponse& response) {
     delegate_->HandlePolicyResponse(response.policy_response());
   }
 
   DeviceManagementBackend::DevicePolicyResponseDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementPolicyJob);
 };
 
-DeviceManagementPolicyJob::DeviceManagementPolicyJob(
-    DeviceManagementBackendImpl* backend_impl,
-    const std::string& device_management_token,
-    const std::string& device_id,
-    const em::DevicePolicyRequest& request,
-    DeviceManagementBackend::DevicePolicyResponseDelegate* delegate)
-    : DeviceManagementJobBase(
+// Handles cloud policy request jobs.
+class CloudPolicyJob : public DeviceManagementJobBase {
+ public:
+  CloudPolicyJob(
+      DeviceManagementBackendImpl* backend_impl,
+      const std::string& device_management_token,
+      const std::string& device_id,
+      const em::CloudPolicyRequest& request,
+      DeviceManagementBackend::DevicePolicyResponseDelegate* delegate)
+      : DeviceManagementJobBase(
           backend_impl,
-          DeviceManagementBackendImpl::kValueRequestPolicy,
+          DeviceManagementBackendImpl::kValueRequestCloudPolicy,
           device_id),
-      delegate_(delegate) {
-  SetDeviceManagementToken(device_management_token);
-  em::DeviceManagementRequest request_wrapper;
-  request_wrapper.mutable_policy_request()->CopyFrom(request);
-  SetPayload(request_wrapper);
-}
+        delegate_(delegate) {
+    SetDeviceManagementToken(device_management_token);
+    em::DeviceManagementRequest request_wrapper;
+    request_wrapper.mutable_cloud_policy_request()->CopyFrom(request);
+    SetPayload(request_wrapper);
+  }
+  virtual ~CloudPolicyJob() {}
+
+ private:
+  // DeviceManagementJobBase overrides.
+  virtual void OnError(DeviceManagementBackend::ErrorCode error) {
+    delegate_->OnError(error);
+  }
+  virtual void OnResponse(const em::DeviceManagementResponse& response) {
+    delegate_->HandleCloudPolicyResponse(response.cloud_policy_response());
+  }
+
+  DeviceManagementBackend::DevicePolicyResponseDelegate* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(CloudPolicyJob);
+};
 
 DeviceManagementBackendImpl::DeviceManagementBackendImpl(
     DeviceManagementService* service)
     : service_(service) {
 }
 
 DeviceManagementBackendImpl::~DeviceManagementBackendImpl() {
   // Swap to a helper, so we don't interfere with the unregistration on delete.
   JobSet to_be_deleted;
   to_be_deleted.swap(pending_jobs_);
@@ skipping 42 matching lines @@
 
 void DeviceManagementBackendImpl::ProcessPolicyRequest(
     const std::string& device_management_token,
     const std::string& device_id,
     const em::DevicePolicyRequest& request,
     DevicePolicyResponseDelegate* delegate) {
   AddJob(new DeviceManagementPolicyJob(this, device_management_token, device_id,
                                        request, delegate));
 }
 
+void DeviceManagementBackendImpl::ProcessCloudPolicyRequest(
+    const std::string& device_management_token,
+    const std::string& device_id,
+    const em::CloudPolicyRequest& request,
+    DevicePolicyResponseDelegate* delegate) {
+  AddJob(new CloudPolicyJob(this, device_management_token, device_id,
+                            request, delegate));
+}
+
 }  // namespace policy