base::Callback-ify policy::DeviceManagementService.

chrome/browser/policy/device_management_service_unittest.cc

Index: chrome/browser/policy/device_management_service_unittest.cc
diff --git a/chrome/browser/policy/device_management_service_unittest.cc b/chrome/browser/policy/device_management_service_unittest.cc
index 48c4be5e53d13075641f62a3d16628a808fd5975..352d7bce7de98dc366599ad1ed31d9a0ddca7020 100644
--- a/chrome/browser/policy/device_management_service_unittest.cc
+++ b/chrome/browser/policy/device_management_service_unittest.cc
@@ -5,12 +5,11 @@
 #include <ostream>
 #include <vector>
 
+#include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/string_split.h"
-#include "chrome/browser/policy/device_management_backend_impl.h"
-#include "chrome/browser/policy/device_management_backend_mock.h"
+#include "chrome/browser/policy/cloud_policy_constants.h"
 #include "chrome/browser/policy/device_management_service.h"
-#include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "content/test/test_browser_thread.h"
 #include "content/test/test_url_fetcher_factory.h"
@@ -24,7 +23,6 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
-using testing::IgnoreResult;
 using testing::InvokeWithoutArgs;

[Joao da Silva, 2012/01/02 16:14:43]

Nit: not used

[Mattias Nissler (ping if slow), 2012/01/02 17:53:23]

Done.

 using testing::_;
 
@@ -43,13 +41,12 @@ const char kResponseEmpty[] = "\x08\x00";
 const char kGaiaAuthToken[] = "gaia-auth-token";
 const char kOAuthToken[] = "oauth-token";
 const char kDMToken[] = "device-management-token";
-const char kDeviceId[] = "device-id";
+const char kClientID[] = "device-id";
 
 // Unit tests for the device management policy service. The tests are run
 // against a TestURLFetcherFactory that is used to short-circuit the request
 // without calling into the actual network stack.
-template<typename TESTBASE>
-class DeviceManagementServiceTestBase : public TESTBASE {
+class DeviceManagementServiceTestBase : public testing::Test {
  protected:
   DeviceManagementServiceTestBase()
       : ui_thread_(BrowserThread::UI, &loop_),
@@ -59,16 +56,12 @@ class DeviceManagementServiceTestBase : public TESTBASE {
   }
 
   virtual void TearDown() {
-    backend_.reset();
     service_.reset();
     loop_.RunAllPending();
-    TESTBASE::TearDown();
   }
 
   void ResetService() {
-    backend_.reset();
     service_.reset(new DeviceManagementService(kServiceUrl));
-    backend_.reset(service_->CreateBackend());
   }
 
   void InitializeService() {
@@ -76,9 +69,72 @@ class DeviceManagementServiceTestBase : public TESTBASE {
     loop_.RunAllPending();
   }
 
+  DeviceManagementRequestJob* StartRegistrationJob() {
+    DeviceManagementRequestJob* job =
+        service_->CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION);
+    job->SetGaiaToken(kGaiaAuthToken);
+    job->SetOAuthToken(kOAuthToken);
+    job->SetClientID(kClientID);
+    job->GetRequest()->mutable_register_request();
+    job->Start(base::Bind(&DeviceManagementServiceTestBase::OnJobDone,
+                          base::Unretained(this)));
+    return job;
+  }
+
+  DeviceManagementRequestJob* StartUnregistrationJob() {
+    DeviceManagementRequestJob* job =
+        service_->CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION);
+    job->SetDMToken(kDMToken);
+    job->SetClientID(kClientID);
+    job->GetRequest()->mutable_unregister_request();
+    job->Start(base::Bind(&DeviceManagementServiceTestBase::OnJobDone,
+                          base::Unretained(this)));
+    return job;
+  }
+
+  DeviceManagementRequestJob* StartPolicyFetchJob() {
+    DeviceManagementRequestJob* job =
+        service_->CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH);
+    job->SetGaiaToken(kGaiaAuthToken);
+    job->SetOAuthToken(kOAuthToken);
+    job->SetClientID(kClientID);
+    em::PolicyFetchRequest* fetch_request =
+        job->GetRequest()->mutable_policy_request()->add_request();
+    fetch_request->set_policy_type(dm_protocol::kChromeUserPolicyType);
+    job->Start(base::Bind(&DeviceManagementServiceTestBase::OnJobDone,
+                          base::Unretained(this)));
+    return job;
+  }
+
+  DeviceManagementRequestJob* StartAutoEnrollmentJob() {
+    DeviceManagementRequestJob* job =
+        service_->CreateJob(DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT);
+    job->SetClientID(kClientID);
+    em::DeviceAutoEnrollmentRequest* request =
+        job->GetRequest()->mutable_auto_enrollment_request();
+    request->set_modulus(1);
+    request->set_remainder(0);
+    job->Start(base::Bind(&DeviceManagementServiceTestBase::OnJobDone,
+                          base::Unretained(this)));
+    return job;
+  }
+
+  void SendResponse(TestURLFetcher* fetcher,
+                    const net::URLRequestStatus request_status,
+                    int http_status,
+                    const std::string& response) {
+    fetcher->set_url(GURL(kServiceUrl));
+    fetcher->set_status(request_status);
+    fetcher->set_response_code(http_status);
+    fetcher->SetResponseString(response);
+    fetcher->delegate()->OnURLFetchComplete(fetcher);
+  }
+
+  MOCK_METHOD2(OnJobDone, void(DeviceManagementStatus,
+                               const em::DeviceManagementResponse&));
+
   TestURLFetcherFactory factory_;
   scoped_ptr<DeviceManagementService> service_;
-  scoped_ptr<DeviceManagementBackend> backend_;
 
  private:
   MessageLoopForUI loop_;
@@ -87,23 +143,23 @@ class DeviceManagementServiceTestBase : public TESTBASE {
 };
 
 struct FailedRequestParams {
-  FailedRequestParams(DeviceManagementBackend::ErrorCode expected_error,
+  FailedRequestParams(DeviceManagementStatus expected_status,
                       net::URLRequestStatus::Status request_status,
                       int http_status,
                       const std::string& response)
-      : expected_error_(expected_error),
+      : expected_status_(expected_status),
         request_status_(request_status, 0),
         http_status_(http_status),
         response_(response) {}
 
-  DeviceManagementBackend::ErrorCode expected_error_;
+  DeviceManagementStatus expected_status_;
   net::URLRequestStatus request_status_;
   int http_status_;
   std::string response_;
 };
 
 void PrintTo(const FailedRequestParams& params, std::ostream* os) {
-  *os << "FailedRequestParams " << params.expected_error_
+  *os << "FailedRequestParams " << params.expected_status_
       << " " << params.request_status_.status()
       << " " << params.http_status_;
 }
@@ -111,77 +167,48 @@ void PrintTo(const FailedRequestParams& params, std::ostream* os) {
 // A parameterized test case for erroneous response situations, they're mostly
 // the same for all kinds of requests.
 class DeviceManagementServiceFailedRequestTest
-    : public DeviceManagementServiceTestBase<
-          testing::TestWithParam<FailedRequestParams> > {
+    : public DeviceManagementServiceTestBase,
+      public testing::WithParamInterface<FailedRequestParams> {
 };
 
 TEST_P(DeviceManagementServiceFailedRequestTest, RegisterRequest) {
-  DeviceRegisterResponseDelegateMock mock;
-  EXPECT_CALL(mock, OnError(GetParam().expected_error_));
-  em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
-                                   kDeviceId, request, &mock);
+  EXPECT_CALL(*this, OnJobDone(GetParam().expected_status_, _));
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
-  fetcher->set_url(GURL(kServiceUrl));
-  fetcher->set_status(GetParam().request_status_);
-  fetcher->set_response_code(GetParam().http_status_);
-  fetcher->SetResponseString(GetParam().response_);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  SendResponse(fetcher, GetParam().request_status_, GetParam().http_status_,
+               GetParam().response_);
 }
 
 TEST_P(DeviceManagementServiceFailedRequestTest, UnregisterRequest) {
-  DeviceUnregisterResponseDelegateMock mock;
-  EXPECT_CALL(mock, OnError(GetParam().expected_error_));
-  em::DeviceUnregisterRequest request;
-  backend_->ProcessUnregisterRequest(kDMToken, kDeviceId, request, &mock);
+  EXPECT_CALL(*this, OnJobDone(GetParam().expected_status_, _));
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartUnregistrationJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
-  fetcher->set_url(GURL(kServiceUrl));
-  fetcher->set_status(GetParam().request_status_);
-  fetcher->set_response_code(GetParam().http_status_);
-  fetcher->SetResponseString(GetParam().response_);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  SendResponse(fetcher, GetParam().request_status_, GetParam().http_status_,
+               GetParam().response_);
 }
 
 TEST_P(DeviceManagementServiceFailedRequestTest, PolicyRequest) {
-  DevicePolicyResponseDelegateMock mock;
-  EXPECT_CALL(mock, OnError(GetParam().expected_error_));
-  em::DevicePolicyRequest request;
-  request.set_policy_scope(kChromePolicyScope);
-  em::DevicePolicySettingRequest* setting_request =
-      request.add_setting_request();
-  setting_request->set_key(kChromeDevicePolicySettingKey);
-  backend_->ProcessPolicyRequest(kDMToken, kDeviceId,
-                                 CloudPolicyDataStore::USER_AFFILIATION_NONE,
-                                 request, NULL, &mock);
+  EXPECT_CALL(*this, OnJobDone(GetParam().expected_status_, _));
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartPolicyFetchJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
-  fetcher->set_url(GURL(kServiceUrl));
-  fetcher->set_status(GetParam().request_status_);
-  fetcher->set_response_code(GetParam().http_status_);
-  fetcher->SetResponseString(GetParam().response_);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  SendResponse(fetcher, GetParam().request_status_, GetParam().http_status_,
+               GetParam().response_);
 }
 
 TEST_P(DeviceManagementServiceFailedRequestTest, AutoEnrollmentRequest) {
-  DeviceAutoEnrollmentResponseDelegateMock mock;
-  EXPECT_CALL(mock, OnError(GetParam().expected_error_));
-  em::DeviceAutoEnrollmentRequest request;
-  request.set_modulus(1);
-  request.set_remainder(0);
-  backend_->ProcessAutoEnrollmentRequest(kDeviceId, request, &mock);
+  EXPECT_CALL(*this, OnJobDone(GetParam().expected_status_, _));
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartAutoEnrollmentJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
-  fetcher->set_url(GURL(kServiceUrl));
-  fetcher->set_status(GetParam().request_status_);
-  fetcher->set_response_code(GetParam().http_status_);
-  fetcher->SetResponseString(GetParam().response_);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  SendResponse(fetcher, GetParam().request_status_, GetParam().http_status_,
+               GetParam().response_);
 }
 
 INSTANTIATE_TEST_CASE_P(
@@ -189,69 +216,69 @@ INSTANTIATE_TEST_CASE_P(
     DeviceManagementServiceFailedRequestTest,
     testing::Values(
         FailedRequestParams(
-            DeviceManagementBackend::kErrorRequestFailed,
+            DM_STATUS_REQUEST_FAILED,
             net::URLRequestStatus::FAILED,
             200,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
-            DeviceManagementBackend::kErrorHttpStatus,
+            DM_STATUS_HTTP_STATUS_ERROR,
             net::URLRequestStatus::SUCCESS,
             666,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
-            DeviceManagementBackend::kErrorResponseDecoding,
+            DM_STATUS_RESPONSE_DECODING_ERROR,
             net::URLRequestStatus::SUCCESS,
             200,
             PROTO_STRING("Not a protobuf.")),
         FailedRequestParams(
-            DeviceManagementBackend::kErrorServiceManagementNotSupported,
+            DM_STATUS_SERVICE_MANAGEMENT_NOT_SUPPORTED,
             net::URLRequestStatus::SUCCESS,
             403,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
-            DeviceManagementBackend::kErrorServiceInvalidSerialNumber,
+            DM_STATUS_SERVICE_INVALID_SERIAL_NUMBER,
             net::URLRequestStatus::SUCCESS,
             405,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
-            DeviceManagementBackend::kErrorServiceDeviceIdConflict,
+            DM_STATUS_SERVICE_DEVICE_ID_CONFLICT,
             net::URLRequestStatus::SUCCESS,
             409,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
-            DeviceManagementBackend::kErrorServiceDeviceNotFound,
+            DM_STATUS_SERVICE_DEVICE_NOT_FOUND,
             net::URLRequestStatus::SUCCESS,
             410,
             PROTO_STRING(kResponseEmpty)),
         // TODO(pastarmovj): Remove once DM server is deployed.
         FailedRequestParams(
-            DeviceManagementBackend::kErrorServiceDeviceNotFound,
+            DM_STATUS_SERVICE_DEVICE_NOT_FOUND,
             net::URLRequestStatus::SUCCESS,
             901,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
-            DeviceManagementBackend::kErrorServiceManagementTokenInvalid,
+            DM_STATUS_SERVICE_MANAGEMENT_TOKEN_INVALID,
             net::URLRequestStatus::SUCCESS,
             401,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
-            DeviceManagementBackend::kErrorRequestInvalid,
+            DM_STATUS_REQUEST_INVALID,
             net::URLRequestStatus::SUCCESS,
             400,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
-            DeviceManagementBackend::kErrorTemporaryUnavailable,
+            DM_STATUS_TEMPORARY_UNAVAILABLE,
             net::URLRequestStatus::SUCCESS,
             404,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
-            DeviceManagementBackend::kErrorServiceActivationPending,
+            DM_STATUS_SERVICE_ACTIVATION_PENDING,
             net::URLRequestStatus::SUCCESS,
             412,
             PROTO_STRING(kResponseEmpty)),
         // TODO(pastarmovj): Remove once DM server is deployed.
         FailedRequestParams(
-            DeviceManagementBackend::kErrorServiceActivationPending,
+            DM_STATUS_SERVICE_ACTIVATION_PENDING,
             net::URLRequestStatus::SUCCESS,
             491,
             PROTO_STRING(kResponseEmpty))));
@@ -297,12 +324,7 @@ class QueryParams {
 };
 
 class DeviceManagementServiceTest
-    : public DeviceManagementServiceTestBase<testing::Test> {
- public:
-  void ResetBackend() {
-    backend_.reset();
-  }
-
+    : public DeviceManagementServiceTestBase {
  protected:
   void CheckURLAndQueryParams(const GURL& request_url,
                               const std::string& request_type,
@@ -314,19 +336,12 @@ class DeviceManagementServiceTest
     EXPECT_EQ(service_url.path(), request_url.path());
 
     QueryParams query_params(request_url.query());
-    EXPECT_TRUE(query_params.Check(
-        DeviceManagementBackendImpl::kParamRequest, request_type));
-    EXPECT_TRUE(query_params.Check(
-        DeviceManagementBackendImpl::kParamDeviceID, device_id));
-    EXPECT_TRUE(query_params.Check(
-        DeviceManagementBackendImpl::kParamDeviceType,
-        DeviceManagementBackendImpl::kValueDeviceType));
-    EXPECT_TRUE(query_params.Check(
-        DeviceManagementBackendImpl::kParamAppType,
-        DeviceManagementBackendImpl::kValueAppType));
-    EXPECT_TRUE(query_params.Check(
-        DeviceManagementBackendImpl::kParamAgent,
-        DeviceManagementBackendImpl::GetAgentString()));
+    EXPECT_TRUE(query_params.Check(dm_protocol::kParamRequest, request_type));
+    EXPECT_TRUE(query_params.Check(dm_protocol::kParamDeviceID, device_id));
+    EXPECT_TRUE(query_params.Check(dm_protocol::kParamDeviceType,
+                                   dm_protocol::kValueDeviceType));
+    EXPECT_TRUE(query_params.Check(dm_protocol::kParamAppType,
+                                   dm_protocol::kValueAppType));
   }
 };
 
@@ -339,46 +354,36 @@ MATCHER_P(MessageEquals, reference, "") {
 }
 
 TEST_F(DeviceManagementServiceTest, RegisterRequest) {
-  DeviceRegisterResponseDelegateMock mock;
-  em::DeviceRegisterResponse expected_response;
-  expected_response.set_device_management_token(kDMToken);
-  EXPECT_CALL(mock, HandleRegisterResponse(MessageEquals(expected_response)));
-  em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
-                                   kDeviceId, request, &mock);
+  em::DeviceManagementResponse expected_response;
+  expected_response.mutable_register_response()->
+      set_device_management_token(kDMToken);
+  EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS,
+                               MessageEquals(expected_response)));
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   CheckURLAndQueryParams(fetcher->GetOriginalURL(),
-                         DeviceManagementBackendImpl::kValueRequestRegister,
-                         kDeviceId);
+                         dm_protocol::kValueRequestRegister,
+                         kClientID);
 
-  em::DeviceManagementRequest expected_request_wrapper;
-  expected_request_wrapper.mutable_register_request()->CopyFrom(request);
-  std::string expected_request_data;
-  ASSERT_TRUE(expected_request_wrapper.SerializeToString(
-      &expected_request_data));
-  EXPECT_EQ(expected_request_data, fetcher->upload_data());
+  std::string expected_data;
+  ASSERT_TRUE(request_job->GetRequest()->SerializeToString(&expected_data));
+  EXPECT_EQ(expected_data, fetcher->upload_data());
 
   // Generate the response.
   std::string response_data;
-  em::DeviceManagementResponse response_wrapper;
-  response_wrapper.mutable_register_response()->CopyFrom(expected_response);
-  ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
+  ASSERT_TRUE(expected_response.SerializeToString(&response_data));
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  fetcher->set_url(GURL(kServiceUrl));
-  fetcher->set_status(status);
-  fetcher->set_response_code(200);
-  fetcher->SetResponseString(response_data);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  SendResponse(fetcher, status, 200, response_data);
 }
 
 TEST_F(DeviceManagementServiceTest, UnregisterRequest) {
-  DeviceUnregisterResponseDelegateMock mock;
-  em::DeviceUnregisterResponse expected_response;
-  EXPECT_CALL(mock, HandleUnregisterResponse(MessageEquals(expected_response)));
-  em::DeviceUnregisterRequest request;
-  backend_->ProcessUnregisterRequest(kDMToken, kDeviceId, request, &mock);
+  em::DeviceManagementResponse expected_response;
+  expected_response.mutable_unregister_response();
+  EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS,
+                               MessageEquals(expected_response)));
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartUnregistrationJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
@@ -391,85 +396,62 @@ TEST_F(DeviceManagementServiceTest, UnregisterRequest) {
   EXPECT_EQ(service_url.path(), request_url.path());
 
   CheckURLAndQueryParams(fetcher->GetOriginalURL(),
-                         DeviceManagementBackendImpl::kValueRequestUnregister,
-                         kDeviceId);
+                         dm_protocol::kValueRequestUnregister,
+                         kClientID);
 
-  em::DeviceManagementRequest expected_request_wrapper;
-  expected_request_wrapper.mutable_unregister_request()->CopyFrom(request);
-  std::string expected_request_data;
-  ASSERT_TRUE(expected_request_wrapper.SerializeToString(
-      &expected_request_data));
-  EXPECT_EQ(expected_request_data, fetcher->upload_data());
+  std::string expected_data;
+  ASSERT_TRUE(request_job->GetRequest()->SerializeToString(&expected_data));
+  EXPECT_EQ(expected_data, fetcher->upload_data());
 
   // Generate the response.
   std::string response_data;
-  em::DeviceManagementResponse response_wrapper;
-  response_wrapper.mutable_unregister_response()->CopyFrom(expected_response);
-  ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
+  ASSERT_TRUE(expected_response.SerializeToString(&response_data));
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  fetcher->set_url(GURL(kServiceUrl));
-  fetcher->set_status(status);
-  fetcher->set_response_code(200);
-  fetcher->SetResponseString(response_data);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  SendResponse(fetcher, status, 200, response_data);
 }
 
 TEST_F(DeviceManagementServiceTest, CancelRegisterRequest) {
-  DeviceRegisterResponseDelegateMock mock;
-  EXPECT_CALL(mock, HandleRegisterResponse(_)).Times(0);
-  em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
-                                   kDeviceId, request, &mock);
+  EXPECT_CALL(*this, OnJobDone(_, _)).Times(0);
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // There shouldn't be any callbacks.
-  backend_.reset();
+  request_job.reset();
 }
 
 TEST_F(DeviceManagementServiceTest, CancelUnregisterRequest) {
-  DeviceUnregisterResponseDelegateMock mock;
-  EXPECT_CALL(mock, HandleUnregisterResponse(_)).Times(0);
-  em::DeviceUnregisterRequest request;
-  backend_->ProcessUnregisterRequest(kDMToken, kDeviceId, request, &mock);
+  EXPECT_CALL(*this, OnJobDone(_, _)).Times(0);
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartUnregistrationJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // There shouldn't be any callbacks.
-  backend_.reset();
+  request_job.reset();
 }
 
 TEST_F(DeviceManagementServiceTest, CancelPolicyRequest) {
-  DevicePolicyResponseDelegateMock mock;
-  EXPECT_CALL(mock, HandlePolicyResponse(_)).Times(0);
-  em::DevicePolicyRequest request;
-  request.set_policy_scope(kChromePolicyScope);
-  em::DevicePolicySettingRequest* setting_request =
-      request.add_setting_request();
-  setting_request->set_key(kChromeDevicePolicySettingKey);
-  setting_request->set_watermark("stale");
-  backend_->ProcessPolicyRequest(kDMToken, kDeviceId,
-                                 CloudPolicyDataStore::USER_AFFILIATION_NONE,
-                                 request, NULL, &mock);
+  EXPECT_CALL(*this, OnJobDone(_, _)).Times(0);
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartPolicyFetchJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // There shouldn't be any callbacks.
-  backend_.reset();
+  request_job.reset();
 }
 
 TEST_F(DeviceManagementServiceTest, JobQueueing) {
   // Start with a non-initialized service.
   ResetService();
 
+  em::DeviceManagementResponse expected_response;
+  expected_response.mutable_register_response()->
+      set_device_management_token(kDMToken);
+  EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS,
+                               MessageEquals(expected_response)));
+
   // Make a request. We should not see any fetchers being created.
-  DeviceRegisterResponseDelegateMock mock;
-  em::DeviceRegisterResponse expected_response;
-  expected_response.set_device_management_token(kDMToken);
-  EXPECT_CALL(mock, HandleRegisterResponse(MessageEquals(expected_response)));
-  em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
-                                   kDeviceId, request, &mock);
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_FALSE(fetcher);
 
@@ -481,70 +463,48 @@ TEST_F(DeviceManagementServiceTest, JobQueueing) {
 
   // Check that the request is processed as expected.
   std::string response_data;
-  em::DeviceManagementResponse response_wrapper;
-  response_wrapper.mutable_register_response()->CopyFrom(expected_response);
-  ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
+  ASSERT_TRUE(expected_response.SerializeToString(&response_data));
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  fetcher->set_url(GURL(kServiceUrl));
-  fetcher->set_status(status);
-  fetcher->set_response_code(200);
-  fetcher->SetResponseString(response_data);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  SendResponse(fetcher, status, 200, response_data);
 }
 
 TEST_F(DeviceManagementServiceTest, CancelRequestAfterShutdown) {
-  DevicePolicyResponseDelegateMock mock;
-  EXPECT_CALL(mock, HandlePolicyResponse(_)).Times(0);
-  em::DevicePolicyRequest request;
-  request.set_policy_scope(kChromePolicyScope);
-  em::DevicePolicySettingRequest* setting_request =
-      request.add_setting_request();
-  setting_request->set_key(kChromeDevicePolicySettingKey);
-  setting_request->set_watermark("stale");
-  backend_->ProcessPolicyRequest(kDMToken, kDeviceId,
-                                 CloudPolicyDataStore::USER_AFFILIATION_NONE,
-                                 request, NULL, &mock);
+  EXPECT_CALL(*this, OnJobDone(_, _)).Times(0);
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartPolicyFetchJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // Shutdown the service and cancel the job afterwards.
   service_->Shutdown();
-  backend_.reset();
+  request_job.reset();
+}
+
+ACTION_P(ResetPointer, pointer) {
+  pointer->reset();
 }
 
 TEST_F(DeviceManagementServiceTest, CancelDuringCallback) {
   // Make a request.
-  DeviceRegisterResponseDelegateMock mock;
-  EXPECT_CALL(mock, OnError(_))
-      .WillOnce(InvokeWithoutArgs(this,
-                                  &DeviceManagementServiceTest::ResetBackend))
-      .RetiresOnSaturation();
-  em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
-                                   kDeviceId, request, &mock);
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
+  EXPECT_CALL(*this, OnJobDone(_, _))
+      .WillOnce(ResetPointer(&request_job));
+
   // Generate a callback.
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  fetcher->set_url(GURL(kServiceUrl));
-  fetcher->set_status(status);
-  fetcher->set_response_code(500);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  SendResponse(fetcher, status, 500, "");
 
-  // Backend should have been reset.
-  EXPECT_FALSE(backend_.get());
+  // Job should have been reset.
+  EXPECT_FALSE(request_job.get());
 }
 
 TEST_F(DeviceManagementServiceTest, RetryOnProxyError) {
   // Make a request.
-  DeviceRegisterResponseDelegateMock mock;
-  EXPECT_CALL(mock, HandleRegisterResponse(_)).Times(0);
-  EXPECT_CALL(mock, OnError(_)).Times(0);
+  EXPECT_CALL(*this, OnJobDone(_, _)).Times(0);
 
-  em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
-                                   kDeviceId, request, &mock);
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_TRUE((fetcher->GetLoadFlags() & net::LOAD_BYPASS_PROXY) == 0);
@@ -554,10 +514,7 @@ TEST_F(DeviceManagementServiceTest, RetryOnProxyError) {
   // Generate a callback with a proxy failure.
   net::URLRequestStatus status(net::URLRequestStatus::FAILED,
                                net::ERR_PROXY_CONNECTION_FAILED);
-  fetcher->set_url(GURL(kServiceUrl));
-  fetcher->set_status(status);
-  fetcher->set_response_code(200);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  SendResponse(fetcher, status, 200, "");
 
   // Verify that a new URLFetcher was started that bypasses the proxy.
   fetcher = factory_.GetFetcherByID(0);
@@ -569,13 +526,9 @@ TEST_F(DeviceManagementServiceTest, RetryOnProxyError) {
 
 TEST_F(DeviceManagementServiceTest, RetryOnBadResponseFromProxy) {
   // Make a request.
-  DeviceRegisterResponseDelegateMock mock;
-  EXPECT_CALL(mock, HandleRegisterResponse(_)).Times(0);
-  EXPECT_CALL(mock, OnError(_)).Times(0);
+  EXPECT_CALL(*this, OnJobDone(_, _)).Times(0);
 
-  em::DeviceRegisterRequest request;
-  backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
-                                   kDeviceId, request, &mock);
+  scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_TRUE((fetcher->GetLoadFlags() & net::LOAD_BYPASS_PROXY) == 0);
@@ -590,10 +543,7 @@ TEST_F(DeviceManagementServiceTest, RetryOnBadResponseFromProxy) {
   // Generate a callback with a valid http response, that was generated by
   // a bad/wrong proxy.
   net::URLRequestStatus status;
-  fetcher->set_url(GURL(kServiceUrl));
-  fetcher->set_status(status);
-  fetcher->set_response_code(200);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  SendResponse(fetcher, status, 200, "");
 
   // Verify that a new URLFetcher was started that bypasses the proxy.
   fetcher = factory_.GetFetcherByID(0);