Tests for cloud policy UMA metrics.

chrome/browser/policy/mock_device_management_service.h

 // 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_MOCK_DEVICE_MANAGEMENT_SERVICE_H_
 #define CHROME_BROWSER_POLICY_MOCK_DEVICE_MANAGEMENT_SERVICE_H_
 #pragma once
 
 #include <string>
 
+#include "base/basictypes.h"
 #include "chrome/browser/policy/device_management_backend.h"
 #include "chrome/browser/policy/device_management_service.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
+#include "net/url_request/url_request_status.h"
 
 namespace policy {
 
 // This proxy class is used so that expectations can be defined for a single
 // persistent instance of DMBackend while the DeviceTokenFetcher under test
 // merrily creates and destroys proxies.
 class ProxyDeviceManagementBackend : public DeviceManagementBackend {
  public:
   explicit ProxyDeviceManagementBackend(DeviceManagementBackend* backend);
   virtual ~ProxyDeviceManagementBackend();
 
   virtual void ProcessRegisterRequest(
       const std::string& auth_token,
       const std::string& device_id,
       const em::DeviceRegisterRequest& request,
-      DeviceRegisterResponseDelegate* delegate);
+      DeviceRegisterResponseDelegate* delegate) OVERRIDE;
 
   virtual void ProcessUnregisterRequest(
       const std::string& device_management_token,
       const std::string& device_id,
       const em::DeviceUnregisterRequest& request,
-      DeviceUnregisterResponseDelegate* delegate);
+      DeviceUnregisterResponseDelegate* delegate) OVERRIDE;
 
   virtual void ProcessPolicyRequest(
       const std::string& device_management_token,
       const std::string& device_id,
       const em::DevicePolicyRequest& request,
-      DevicePolicyResponseDelegate* delegate);
+      DevicePolicyResponseDelegate* delegate) OVERRIDE;
 
  private:
   DeviceManagementBackend* backend_;  // weak
   DISALLOW_COPY_AND_ASSIGN(ProxyDeviceManagementBackend);
 };
 
 class MockDeviceManagementService : public DeviceManagementService {
  public:
   MockDeviceManagementService();
   virtual ~MockDeviceManagementService();
 
+  // If backend is set, this mock will just provide proxies for it on calls
+  // to CreateBackend().
   void set_backend(DeviceManagementBackend* backend) {
     backend_ = backend;
   }
 
-  virtual DeviceManagementBackend* CreateBackend();
+  virtual DeviceManagementBackend* CreateBackend() OVERRIDE;
+
+  // If the backend is set, this method will pass-through to the super class.
+  // Otherwise, this method will use the parameters stored and complete the
+  // job immediately.
+  virtual void StartJob(DeviceManagementJob* job) OVERRIDE;
+
+  void set_url_request_status(const net::URLRequestStatus& status) {
+    status_ = status;
+  }
+
+  void set_response_code(int response_code) {
+    response_code_ = response_code;
+  }
+
+  void set_cookies(const net::ResponseCookies& cookies) {
+    cookies_ = cookies;
+  }
+
+  void set_data(const std::string& data) {
+    data_ = data;
+  }
 
  private:
   DeviceManagementBackend* backend_;  // weak
+  net::URLRequestStatus status_;
+  int response_code_;
+  net::ResponseCookies cookies_;
+  std::string data_;
   DISALLOW_COPY_AND_ASSIGN(MockDeviceManagementService);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_MOCK_DEVICE_MANAGEMENT_SERVICE_H_