Initial RemoteCommandService

chrome/browser/policy/cloud/test_request_interceptor.cc

 // Copyright (c) 2013 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/cloud/test_request_interceptor.h"
 
 #include <limits>
 #include <queue>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
+#include "chrome/browser/policy/remote_commands/testing_remote_commands_server.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_element_reader.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_test_job.h"
 #include "url/gurl.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
+static const char kGoodHeaders[] =
+    "HTTP/1.1 200 OK\0"
+    "Content-type: application/protobuf\0"
+    "\0";
+static const char kBadHeaders[] =
+    "HTTP/1.1 400 Bad request\0"
+    "Content-type: application/protobuf\0"
+    "\0";
+
 // Helper callback for jobs that should fail with a network |error|.
 net::URLRequestJob* ErrorJobCallback(int error,
                                      net::URLRequest* request,
                                      net::NetworkDelegate* network_delegate) {
   return new net::URLRequestErrorJob(request, network_delegate, error);
 }
 
 // Helper callback for jobs that should fail with a 400 HTTP error.
 net::URLRequestJob* BadRequestJobCallback(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) {
-  static const char kBadHeaders[] =
-      "HTTP/1.1 400 Bad request\0"
-      "Content-type: application/protobuf\0"
-      "\0";
   std::string headers(kBadHeaders, arraysize(kBadHeaders));
   return new net::URLRequestTestJob(
       request, network_delegate, headers, std::string(), true);
 }
 
 net::URLRequestJob* FileJobCallback(const base::FilePath& file_path,
                                     net::URLRequest* request,
                                     net::NetworkDelegate* network_delegate) {
   return new net::URLRequestMockHTTPJob(
       request,
@@ skipping 48 matching lines @@
     net::NetworkDelegate* network_delegate) {
   em::DeviceManagementRequest request_msg;
   if (!ValidRequest(request, "register", &request_msg))
     return BadRequestJobCallback(request, network_delegate);
 
   if (!request_msg.has_register_request() ||
       request_msg.has_unregister_request() ||
       request_msg.has_policy_request() ||
       request_msg.has_device_status_report_request() ||
       request_msg.has_session_status_report_request() ||
-      request_msg.has_auto_enrollment_request()) {
+      request_msg.has_auto_enrollment_request() ||
+      request_msg.has_remote_command_request()) {
     return BadRequestJobCallback(request, network_delegate);
   }
 
   const em::DeviceRegisterRequest& register_request =
       request_msg.register_request();
   if (expect_reregister &&
       (!register_request.has_reregister() || !register_request.reregister())) {
     return BadRequestJobCallback(request, network_delegate);
   } else if (!expect_reregister &&
              register_request.has_reregister() &&
              register_request.reregister()) {
     return BadRequestJobCallback(request, network_delegate);
   }
 
   if (!register_request.has_type() || register_request.type() != expected_type)
     return BadRequestJobCallback(request, network_delegate);
 
   em::DeviceManagementResponse response;
   em::DeviceRegisterResponse* register_response =
       response.mutable_register_response();
   register_response->set_device_management_token("s3cr3t70k3n");
   std::string data;
   response.SerializeToString(&data);
 
-  static const char kGoodHeaders[] =
-      "HTTP/1.1 200 OK\0"
-      "Content-type: application/protobuf\0"
-      "\0";
+  std::string headers(kGoodHeaders, arraysize(kGoodHeaders));

[bartfab (slow), 2015/02/12 14:29:17]

Nit: const.

[binjin, 2015/02/16 22:46:22]

Done.

+  return new net::URLRequestTestJob(request, network_delegate, headers, data,
+                                    true);
+}
+
+net::URLRequestJob* FetchRemoteCommandsJobCallback(
+    TestingRemoteCommandsServer* server,
+    bool ignore_other_requests,
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) {
+  em::DeviceManagementRequest request_msg;
+  if (!ValidRequest(request, "remote_commands", &request_msg)) {
+    return ignore_other_requests ? nullptr : BadRequestJobCallback(
+                                                 request, network_delegate);
+  }
+
+  if (!request_msg.has_remote_command_request())
+    return BadRequestJobCallback(request, network_delegate);
+
+  const em::DeviceRemoteCommandRequest& remote_command_request =
+      request_msg.remote_command_request();
+  if (!remote_command_request.has_last_command_unique_id())
+    return BadRequestJobCallback(request, network_delegate);
+
+  std::vector<em::RemoteCommandResult> previous_results(
+      remote_command_request.command_results().begin(),
+      remote_command_request.command_results().end());
+  std::vector<em::RemoteCommand> fetched_commands;
+  server->FetchCommandsFromIO(remote_command_request.last_command_unique_id(),
+                              previous_results, &fetched_commands);
+
+  em::DeviceManagementResponse response;
+  em::DeviceRemoteCommandResponse* remote_command_response =
+      response.mutable_remote_command_response();
+
+  for (const auto& fetched_command : fetched_commands)
+    *remote_command_response->add_commands() = fetched_command;
+  std::string data;
+  response.SerializeToString(&data);
+
   std::string headers(kGoodHeaders, arraysize(kGoodHeaders));
   return new net::URLRequestTestJob(
       request, network_delegate, headers, data, true);
 }
 
 void RegisterHttpInterceptor(
     const std::string& hostname,
     scoped_ptr<net::URLRequestInterceptor> interceptor) {
   net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
       "http", hostname, interceptor.Pass());
@@ skipping 49 matching lines @@
     // Reject requests to other servers.
     return ErrorJobCallback(
         net::ERR_CONNECTION_REFUSED, request, network_delegate);
   }
 
   if (pending_job_callbacks_.empty()) {
     // Reject dmserver requests by default.
     return BadRequestJobCallback(request, network_delegate);
   }
 
+  net::URLRequestJob* new_request =
+      pending_job_callbacks_.front().Run(request, network_delegate);
+
+  if (!new_request) {
+    // The current request job is legal and explicitly ignored by the next
+    // pending job callback.
+    return BadRequestJobCallback(request, network_delegate);

[bartfab (slow), 2015/02/12 14:29:17]

This early return will cause the callbacks below not to run.

[binjin, 2015/02/16 22:46:22]

Yes, it's designed to not be consumed from callback queue. I'd like to ignore
certain package, and to keep this callback for next packet.

+  }
+
+  pending_job_callbacks_.pop();
+
   // Invoke any callbacks that are waiting for the next request to be serviced
   // after this job is serviced.
   if (!request_serviced_callbacks_.empty()) {

[bartfab (slow), 2015/02/12 14:29:17]

These callbacks used to run *before* the ob, now they run *after* the job. Are
you sure this is OK?

[binjin, 2015/02/16 22:46:22]

I think the callback is for intercepting, parsing packages, the actual response
from server will be sent back later. So generally I think it won't cause any
problem but I'm not so sure.

     scoped_ptr<std::vector<base::Closure>> callbacks(
         new std::vector<base::Closure>);
     callbacks->swap(request_serviced_callbacks_);
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Delegate::InvokeRequestServicedCallbacks,
                               base::Passed(&callbacks)));
   }
 
-  JobCallback callback = pending_job_callbacks_.front();
-  pending_job_callbacks_.pop();
-  return callback.Run(request, network_delegate);
+  return new_request;
 }
 
 void TestRequestInterceptor::Delegate::GetPendingSize(
     size_t* pending_size) const {
   CHECK(io_task_runner_->RunsTasksOnCurrentThread());
   *pending_size = pending_job_callbacks_.size();
 }
 
 void TestRequestInterceptor::Delegate::AddRequestServicedCallback(
     const base::Closure& callback) {
@@ skipping 78 matching lines @@
     bool expect_reregister) {
   return base::Bind(&RegisterJobCallback, expected_type, expect_reregister);
 }
 
 // static
 TestRequestInterceptor::JobCallback TestRequestInterceptor::FileJob(
     const base::FilePath& file_path) {
   return base::Bind(&FileJobCallback, file_path);
 }
 
+// static
+TestRequestInterceptor::JobCallback
+TestRequestInterceptor::FetchRemoteCommandsJob(
+    TestingRemoteCommandsServer* server,
+    bool ignore_other_requests) {
+  return base::Bind(&FetchRemoteCommandsJobCallback, server,
+                    ignore_other_requests);
+}
+
 void TestRequestInterceptor::PostToIOAndWait(const base::Closure& task) {
   io_task_runner_->PostTask(FROM_HERE, task);
   base::RunLoop run_loop;
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&base::MessageLoopProxy::PostTask),
           base::MessageLoopProxy::current(),
           FROM_HERE,
           run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 }  // namespace policy