chrome/browser/policy/cloud/test_request_interceptor.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/policy/cloud/test_request_interceptor.h"
   6
   7 #include <limits>
   8 #include <queue>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/run_loop.h"
  14 #include "base/sequenced_task_runner.h"
  15 #include "content/test/net/url_request_mock_http_job.h"
  16 #include "net/base/net_errors.h"
  17 #include "net/base/upload_bytes_element_reader.h"
  18 #include "net/base/upload_data_stream.h"
  19 #include "net/base/upload_element_reader.h"
  20 #include "net/url_request/url_request_error_job.h"
  21 #include "net/url_request/url_request_filter.h"
  22 #include "net/url_request/url_request_job_factory.h"
  23 #include "net/url_request/url_request_test_job.h"
  24 #include "url/gurl.h"
  25
  26 namespace em = enterprise_management;
  27
  28 namespace policy {
  29
  30 namespace {
  31
  32 // Helper callback for jobs that should fail with a network |error|.
  33 net::URLRequestJob* ErrorJobCallback(int error,
  34                                      net::URLRequest* request,
  35                                      net::NetworkDelegate* network_delegate) {
  36   return new net::URLRequestErrorJob(request, network_delegate, error);
  37 }
  38
  39 // Helper callback for jobs that should fail with a 400 HTTP error.
  40 net::URLRequestJob* BadRequestJobCallback(
  41     net::URLRequest* request,
  42     net::NetworkDelegate* network_delegate) {
  43   static const char kBadHeaders[] =
  44       "HTTP/1.1 400 Bad request\0"
  45       "Content-type: application/protobuf\0"
  46       "\0";
  47   std::string headers(kBadHeaders, arraysize(kBadHeaders));
  48   return new net::URLRequestTestJob(
  49       request, network_delegate, headers, std::string(), true);
  50 }
  51
  52 net::URLRequestJob* FileJobCallback(const base::FilePath& file_path,
  53                                     net::URLRequest* request,
  54                                     net::NetworkDelegate* network_delegate) {
  55   return new content::URLRequestMockHTTPJob(
  56       request,
  57       network_delegate,
  58       file_path);
  59 }
  60
  61 // Parses the upload data in |request| into |request_msg|, and validates the
  62 // request. The query string in the URL must contain the |expected_type| for
  63 // the "request" parameter. Returns true if all checks succeeded, and the
  64 // request data has been parsed into |request_msg|.
  65 bool ValidRequest(net::URLRequest* request,
  66                   const std::string& expected_type,
  67                   em::DeviceManagementRequest* request_msg) {
  68   if (request->method() != "POST")
  69     return false;
  70   std::string spec = request->url().spec();
  71   if (spec.find("request=" + expected_type) == std::string::npos)
  72     return false;
  73
  74   // This assumes that the payload data was set from a single string. In that
  75   // case the UploadDataStream has a single UploadBytesElementReader with the
  76   // data in memory.
  77   const net::UploadDataStream* stream = request->get_upload();
  78   if (!stream)
  79     return false;
  80   const ScopedVector<net::UploadElementReader>& readers =
  81       stream->element_readers();
  82   if (readers.size() != 1u)
  83     return false;
  84   const net::UploadBytesElementReader* reader = readers[0]->AsBytesReader();
  85   if (!reader)
  86     return false;
  87   std::string data(reader->bytes(), reader->length());
  88   if (!request_msg->ParseFromString(data))
  89     return false;
  90
  91   return true;
  92 }
  93
  94 // Helper callback for register jobs that should suceed. Validates the request
  95 // parameters and returns an appropriate response job. If |expect_reregister|
  96 // is true then the reregister flag must be set in the DeviceRegisterRequest
  97 // protobuf.
  98 net::URLRequestJob* RegisterJobCallback(
  99     em::DeviceRegisterRequest::Type expected_type,
 100     bool expect_reregister,
 101     net::URLRequest* request,
 102     net::NetworkDelegate* network_delegate) {
 103   em::DeviceManagementRequest request_msg;
 104   if (!ValidRequest(request, "register", &request_msg))
 105     return BadRequestJobCallback(request, network_delegate);
 106
 107   if (!request_msg.has_register_request() ||
 108       request_msg.has_unregister_request() ||
 109       request_msg.has_policy_request() ||
 110       request_msg.has_device_status_report_request() ||
 111       request_msg.has_session_status_report_request() ||
 112       request_msg.has_auto_enrollment_request()) {
 113     return BadRequestJobCallback(request, network_delegate);
 114   }
 115
 116   const em::DeviceRegisterRequest& register_request =
 117       request_msg.register_request();
 118   if (expect_reregister &&
 119       (!register_request.has_reregister() || !register_request.reregister())) {
 120     return BadRequestJobCallback(request, network_delegate);
 121   } else if (!expect_reregister &&
 122              register_request.has_reregister() &&
 123              register_request.reregister()) {
 124     return BadRequestJobCallback(request, network_delegate);
 125   }
 126
 127   if (!register_request.has_type() || register_request.type() != expected_type)
 128     return BadRequestJobCallback(request, network_delegate);
 129
 130   em::DeviceManagementResponse response;
 131   em::DeviceRegisterResponse* register_response =
 132       response.mutable_register_response();
 133   register_response->set_device_management_token("s3cr3t70k3n");
 134   std::string data;
 135   response.SerializeToString(&data);
 136
 137   static const char kGoodHeaders[] =
 138       "HTTP/1.1 200 OK\0"
 139       "Content-type: application/protobuf\0"
 140       "\0";
 141   std::string headers(kGoodHeaders, arraysize(kGoodHeaders));
 142   return new net::URLRequestTestJob(
 143       request, network_delegate, headers, data, true);
 144 }
 145
 146 }  // namespace
 147
 148 class TestRequestInterceptor::Delegate
 149     : public net::URLRequestJobFactory::ProtocolHandler {
 150  public:
 151   Delegate(const std::string& hostname,
 152            scoped_refptr<base::SequencedTaskRunner> io_task_runner);
 153   virtual ~Delegate();
 154
 155   // ProtocolHandler implementation:
 156   virtual net::URLRequestJob* MaybeCreateJob(
 157       net::URLRequest* request,
 158       net::NetworkDelegate* network_delegate) const OVERRIDE;
 159
 160   void GetPendingSize(size_t* pending_size) const;
 161   void PushJobCallback(const JobCallback& callback);
 162
 163  private:
 164   const std::string hostname_;
 165   scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
 166
 167   // The queue of pending callbacks. 'mutable' because MaybeCreateJob() is a
 168   // const method; it can't reenter though, because it runs exclusively on
 169   // the IO thread.
 170   mutable std::queue<JobCallback> pending_job_callbacks_;
 171 };
 172
 173 TestRequestInterceptor::Delegate::Delegate(
 174     const std::string& hostname,
 175     scoped_refptr<base::SequencedTaskRunner> io_task_runner)
 176     : hostname_(hostname), io_task_runner_(io_task_runner) {}
 177
 178 TestRequestInterceptor::Delegate::~Delegate() {}
 179
 180 net::URLRequestJob* TestRequestInterceptor::Delegate::MaybeCreateJob(
 181     net::URLRequest* request,
 182     net::NetworkDelegate* network_delegate) const {
 183   CHECK(io_task_runner_->RunsTasksOnCurrentThread());
 184
 185   if (request->url().host() != hostname_) {
 186     // Reject requests to other servers.
 187     return ErrorJobCallback(
 188         net::ERR_CONNECTION_REFUSED, request, network_delegate);
 189   }
 190
 191   if (pending_job_callbacks_.empty()) {
 192     // Reject dmserver requests by default.
 193     return BadRequestJobCallback(request, network_delegate);
 194   }
 195
 196   JobCallback callback = pending_job_callbacks_.front();
 197   pending_job_callbacks_.pop();
 198   return callback.Run(request, network_delegate);
 199 }
 200
 201 void TestRequestInterceptor::Delegate::GetPendingSize(
 202     size_t* pending_size) const {
 203   CHECK(io_task_runner_->RunsTasksOnCurrentThread());
 204   *pending_size = pending_job_callbacks_.size();
 205 }
 206
 207 void TestRequestInterceptor::Delegate::PushJobCallback(
 208     const JobCallback& callback) {
 209   CHECK(io_task_runner_->RunsTasksOnCurrentThread());
 210   pending_job_callbacks_.push(callback);
 211 }
 212
 213 TestRequestInterceptor::TestRequestInterceptor(const std::string& hostname,
 214     scoped_refptr<base::SequencedTaskRunner> io_task_runner)
 215     : hostname_(hostname),
 216       io_task_runner_(io_task_runner) {
 217   delegate_ = new Delegate(hostname_, io_task_runner_);
 218   scoped_ptr<net::URLRequestJobFactory::ProtocolHandler> handler(delegate_);
 219   PostToIOAndWait(
 220       base::Bind(&net::URLRequestFilter::AddHostnameProtocolHandler,
 221                  base::Unretained(net::URLRequestFilter::GetInstance()),
 222                  "http", hostname_, base::Passed(&handler)));
 223 }
 224
 225 TestRequestInterceptor::~TestRequestInterceptor() {
 226   // RemoveHostnameHandler() destroys the |delegate_|, which is owned by
 227   // the URLRequestFilter.
 228   delegate_ = NULL;
 229   PostToIOAndWait(
 230       base::Bind(&net::URLRequestFilter::RemoveHostnameHandler,
 231                  base::Unretained(net::URLRequestFilter::GetInstance()),
 232                  "http", hostname_));
 233 }
 234
 235 size_t TestRequestInterceptor::GetPendingSize() {
 236   size_t pending_size = std::numeric_limits<size_t>::max();
 237   PostToIOAndWait(base::Bind(&Delegate::GetPendingSize,
 238                              base::Unretained(delegate_),
 239                              &pending_size));
 240   return pending_size;
 241 }
 242
 243 void TestRequestInterceptor::PushJobCallback(const JobCallback& callback) {
 244   PostToIOAndWait(base::Bind(&Delegate::PushJobCallback,
 245                              base::Unretained(delegate_),
 246                              callback));
 247 }
 248
 249 // static
 250 TestRequestInterceptor::JobCallback TestRequestInterceptor::ErrorJob(
 251     int error) {
 252   return base::Bind(&ErrorJobCallback, error);
 253 }
 254
 255 // static
 256 TestRequestInterceptor::JobCallback TestRequestInterceptor::BadRequestJob() {
 257   return base::Bind(&BadRequestJobCallback);
 258 }
 259
 260 // static
 261 TestRequestInterceptor::JobCallback TestRequestInterceptor::RegisterJob(
 262     em::DeviceRegisterRequest::Type expected_type,
 263     bool expect_reregister) {
 264   return base::Bind(&RegisterJobCallback, expected_type, expect_reregister);
 265 }
 266
 267 // static
 268 TestRequestInterceptor::JobCallback TestRequestInterceptor::FileJob(
 269     const base::FilePath& file_path) {
 270   return base::Bind(&FileJobCallback, file_path);
 271 }
 272
 273 void TestRequestInterceptor::PostToIOAndWait(const base::Closure& task) {
 274   io_task_runner_->PostTask(FROM_HERE, task);
 275   base::RunLoop run_loop;
 276   io_task_runner_->PostTask(
 277       FROM_HERE,
 278       base::Bind(
 279           base::IgnoreResult(&base::MessageLoopProxy::PostTask),
 280           base::MessageLoopProxy::current(),
 281           FROM_HERE,
 282           run_loop.QuitClosure()));
 283   run_loop.Run();
 284 }
 285
 286 }  // namespace policy