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