net/proxy/mock_proxy_resolver.cc

   1 // Copyright (c) 2011 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 "net/proxy/mock_proxy_resolver.h"
   6
   7 #include "base/logging.h"
   8 #include "base/message_loop.h"
   9
  10 namespace net {
  11
  12 MockAsyncProxyResolverBase::Request::Request(
  13     MockAsyncProxyResolverBase* resolver, const GURL& url, ProxyInfo* results,
  14     const CompletionCallback& callback)
  15         : resolver_(resolver),
  16           url_(url),
  17           results_(results),
  18           callback_(callback),
  19           origin_loop_(MessageLoop::current()) {
  20     }
  21
  22     void MockAsyncProxyResolverBase::Request::CompleteNow(int rv) {
  23       CompletionCallback callback = callback_;
  24
  25       // May delete |this|.
  26       resolver_->RemovePendingRequest(this);
  27
  28       callback.Run(rv);
  29     }
  30
  31 MockAsyncProxyResolverBase::Request::~Request() {}
  32
  33
  34 MockAsyncProxyResolverBase::SetPacScriptRequest::SetPacScriptRequest(
  35         MockAsyncProxyResolverBase* resolver,
  36         const scoped_refptr<ProxyResolverScriptData>& script_data,
  37         const CompletionCallback& callback)
  38         : resolver_(resolver),
  39           script_data_(script_data),
  40           callback_(callback),
  41           origin_loop_(MessageLoop::current()) {
  42     }
  43
  44 MockAsyncProxyResolverBase::SetPacScriptRequest::~SetPacScriptRequest() {}
  45
  46     void MockAsyncProxyResolverBase::SetPacScriptRequest::CompleteNow(int rv) {
  47        CompletionCallback callback = callback_;
  48
  49       // Will delete |this|.
  50       resolver_->RemovePendingSetPacScriptRequest(this);
  51
  52       callback.Run(rv);
  53     }
  54
  55 MockAsyncProxyResolverBase::~MockAsyncProxyResolverBase() {}
  56
  57 int MockAsyncProxyResolverBase::GetProxyForURL(
  58     const GURL& url, ProxyInfo* results, const CompletionCallback& callback,
  59     RequestHandle* request_handle, const BoundNetLog& /*net_log*/) {
  60   scoped_refptr<Request> request = new Request(this, url, results, callback);
  61   pending_requests_.push_back(request);
  62
  63   if (request_handle)
  64     *request_handle = reinterpret_cast<RequestHandle>(request.get());
  65
  66   // Test code completes the request by calling request->CompleteNow().
  67   return ERR_IO_PENDING;
  68 }
  69
  70 void MockAsyncProxyResolverBase::CancelRequest(RequestHandle request_handle) {
  71   scoped_refptr<Request> request = reinterpret_cast<Request*>(request_handle);
  72   cancelled_requests_.push_back(request);
  73   RemovePendingRequest(request);
  74 }
  75
  76 LoadState MockAsyncProxyResolverBase::GetLoadState(
  77     RequestHandle request_handle) const {
  78   NOTREACHED();
  79   return LOAD_STATE_IDLE;
  80 }
  81
  82 LoadState MockAsyncProxyResolverBase::GetLoadStateThreadSafe(
  83     RequestHandle request_handle) const {
  84   NOTREACHED();
  85   return LOAD_STATE_IDLE;
  86 }
  87
  88 int MockAsyncProxyResolverBase::SetPacScript(
  89     const scoped_refptr<ProxyResolverScriptData>& script_data,
  90     const CompletionCallback& callback) {
  91   DCHECK(!pending_set_pac_script_request_.get());
  92   pending_set_pac_script_request_.reset(
  93       new SetPacScriptRequest(this, script_data, callback));
  94   // Finished when user calls SetPacScriptRequest::CompleteNow().
  95   return ERR_IO_PENDING;
  96 }
  97
  98 void MockAsyncProxyResolverBase::CancelSetPacScript() {
  99   // Do nothing (caller was responsible for completing the request).
 100 }
 101
 102 MockAsyncProxyResolverBase::SetPacScriptRequest*
 103 MockAsyncProxyResolverBase::pending_set_pac_script_request() const {
 104   return pending_set_pac_script_request_.get();
 105 }
 106
 107 void MockAsyncProxyResolverBase::RemovePendingRequest(Request* request) {
 108   RequestsList::iterator it = std::find(
 109       pending_requests_.begin(), pending_requests_.end(), request);
 110   DCHECK(it != pending_requests_.end());
 111   pending_requests_.erase(it);
 112 }
 113
 114 void MockAsyncProxyResolverBase::RemovePendingSetPacScriptRequest(
 115     SetPacScriptRequest* request) {
 116   DCHECK_EQ(request, pending_set_pac_script_request());
 117   pending_set_pac_script_request_.reset();
 118 }
 119
 120 MockAsyncProxyResolverBase::MockAsyncProxyResolverBase(bool expects_pac_bytes)
 121     : ProxyResolver(expects_pac_bytes) {}
 122
 123 }  // namespace net