Move url_request_test_util into net namespace

net/url_request/url_request_test_util.h

 // Copyright (c) 2012 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
 #define NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
 
 #include <stdlib.h>
 
 #include <map>
@@ skipping 23 matching lines @@
 #include "net/http/http_network_layer.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_context_storage.h"
 #include "net/url_request/url_request_job_factory.h"
 
 using base::TimeDelta;
 
+namespace net {
+
 //-----------------------------------------------------------------------------
 
-class TestURLRequestContext : public net::URLRequestContext {
+class TestURLRequestContext : public URLRequestContext {
  public:
   TestURLRequestContext();
   // Default constructor like TestURLRequestContext() but does not call
   // Init() in case |delay_initialization| is true. This allows modifying the
   // URLRequestContext before it is constructed completely. If
   // |delay_initialization| is true, Init() needs be be called manually.
   explicit TestURLRequestContext(bool delay_initialization);
   virtual ~TestURLRequestContext();
 
   void Init();
 
  private:
   bool initialized_;
 
  protected:
-  net::URLRequestContextStorage context_storage_;
+  URLRequestContextStorage context_storage_;
 };
 
 //-----------------------------------------------------------------------------
 
 // Used to return a dummy context, which lives on the message loop
 // given in the constructor.
-class TestURLRequestContextGetter : public net::URLRequestContextGetter {
+class TestURLRequestContextGetter : public URLRequestContextGetter {
  public:
   // |network_task_runner| must not be NULL.
   explicit TestURLRequestContextGetter(
       const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner);
 
   // Use to pass a pre-initialized |context|.
   TestURLRequestContextGetter(
       const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
       scoped_ptr<TestURLRequestContext> context);
 
-  // net::URLRequestContextGetter implementation.
+  // URLRequestContextGetter implementation.
   virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE;
   virtual scoped_refptr<base::SingleThreadTaskRunner>
       GetNetworkTaskRunner() const OVERRIDE;
 
  protected:
   virtual ~TestURLRequestContextGetter();
 
  private:
   const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
   scoped_ptr<TestURLRequestContext> context_;
 };
 
 //-----------------------------------------------------------------------------
 
-class TestURLRequest : public net::URLRequest {
+class TestURLRequest : public URLRequest {
  public:
   TestURLRequest(
       const GURL& url, Delegate* delegate, TestURLRequestContext* context);
   virtual ~TestURLRequest();
 };
 
 //-----------------------------------------------------------------------------
 
-class TestDelegate : public net::URLRequest::Delegate {
+class TestDelegate : public URLRequest::Delegate {
  public:
   TestDelegate();
   virtual ~TestDelegate();
 
   void set_cancel_in_received_redirect(bool val) { cancel_in_rr_ = val; }
   void set_cancel_in_response_started(bool val) { cancel_in_rs_ = val; }
   void set_cancel_in_received_data(bool val) { cancel_in_rd_ = val; }
   void set_cancel_in_received_data_pending(bool val) {
     cancel_in_rd_pending_ = val;
   }
   void set_quit_on_complete(bool val) { quit_on_complete_ = val; }
   void set_quit_on_redirect(bool val) { quit_on_redirect_ = val; }
   void set_allow_certificate_errors(bool val) {
     allow_certificate_errors_ = val;
   }
-  void set_credentials(const net::AuthCredentials& credentials) {
+  void set_credentials(const AuthCredentials& credentials) {
     credentials_ = credentials;
   }
 
   // query state
   const std::string& data_received() const { return data_received_; }
   int bytes_received() const { return static_cast<int>(data_received_.size()); }
   int response_started_count() const { return response_started_count_; }
   int received_redirect_count() const { return received_redirect_count_; }
   bool received_data_before_response() const {
     return received_data_before_response_;
   }
   bool request_failed() const { return request_failed_; }
   bool have_certificate_errors() const { return have_certificate_errors_; }
   bool certificate_errors_are_fatal() const {
     return certificate_errors_are_fatal_;
   }
   bool auth_required_called() const { return auth_required_; }
 
-  // net::URLRequest::Delegate:
-  virtual void OnReceivedRedirect(net::URLRequest* request, const GURL& new_url,
+  // URLRequest::Delegate:
+  virtual void OnReceivedRedirect(URLRequest* request, const GURL& new_url,
                                   bool* defer_redirect) OVERRIDE;
-  virtual void OnAuthRequired(net::URLRequest* request,
-                              net::AuthChallengeInfo* auth_info) OVERRIDE;
+  virtual void OnAuthRequired(URLRequest* request,
+                              AuthChallengeInfo* auth_info) OVERRIDE;
   // NOTE: |fatal| causes |certificate_errors_are_fatal_| to be set to true.
   // (Unit tests use this as a post-condition.) But for policy, this method
   // consults |allow_certificate_errors_|.
-  virtual void OnSSLCertificateError(net::URLRequest* request,
-                                     const net::SSLInfo& ssl_info,
+  virtual void OnSSLCertificateError(URLRequest* request,
+                                     const SSLInfo& ssl_info,
                                      bool fatal) OVERRIDE;
-  virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
-  virtual void OnReadCompleted(net::URLRequest* request,
+  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+  virtual void OnReadCompleted(URLRequest* request,
                                int bytes_read) OVERRIDE;
 
  private:
   static const int kBufferSize = 4096;
 
-  virtual void OnResponseCompleted(net::URLRequest* request);
+  virtual void OnResponseCompleted(URLRequest* request);
 
   // options for controlling behavior
   bool cancel_in_rr_;
   bool cancel_in_rs_;
   bool cancel_in_rd_;
   bool cancel_in_rd_pending_;
   bool quit_on_complete_;
   bool quit_on_redirect_;
   bool allow_certificate_errors_;
-  net::AuthCredentials credentials_;
+  AuthCredentials credentials_;
 
   // tracks status of callbacks
   int response_started_count_;
   int received_bytes_count_;
   int received_redirect_count_;
   bool received_data_before_response_;
   bool request_failed_;
   bool have_certificate_errors_;
   bool certificate_errors_are_fatal_;
   bool auth_required_;
   std::string data_received_;
 
   // our read buffer
-  scoped_refptr<net::IOBuffer> buf_;
+  scoped_refptr<IOBuffer> buf_;
 };
 
 //-----------------------------------------------------------------------------
 
-class TestNetworkDelegate : public net::NetworkDelegate {
+class TestNetworkDelegate : public NetworkDelegate {
  public:
   enum Options {
     NO_GET_COOKIES = 1 << 0,
     NO_SET_COOKIE  = 1 << 1,
   };
 
   TestNetworkDelegate();
   virtual ~TestNetworkDelegate();
 
   void set_cookie_options(int o) {cookie_options_bit_mask_ = o; }
 
   int last_error() const { return last_error_; }
   int error_count() const { return error_count_; }
   int created_requests() const { return created_requests_; }
   int destroyed_requests() const { return destroyed_requests_; }
   int completed_requests() const { return completed_requests_; }
   int blocked_get_cookies_count() const { return blocked_get_cookies_count_; }
   int blocked_set_cookie_count() const { return blocked_set_cookie_count_; }
   int set_cookie_count() const { return set_cookie_count_; }
 
  protected:
-  // net::NetworkDelegate:
-  virtual int OnBeforeURLRequest(net::URLRequest* request,
-                                 const net::CompletionCallback& callback,
+  // NetworkDelegate:
+  virtual int OnBeforeURLRequest(URLRequest* request,
+                                 const CompletionCallback& callback,
                                  GURL* new_url) OVERRIDE;
-  virtual int OnBeforeSendHeaders(net::URLRequest* request,
-                                  const net::CompletionCallback& callback,
-                                  net::HttpRequestHeaders* headers) OVERRIDE;
-  virtual void OnSendHeaders(net::URLRequest* request,
-                             const net::HttpRequestHeaders& headers) OVERRIDE;
+  virtual int OnBeforeSendHeaders(URLRequest* request,
+                                  const CompletionCallback& callback,
+                                  HttpRequestHeaders* headers) OVERRIDE;
+  virtual void OnSendHeaders(URLRequest* request,
+                             const HttpRequestHeaders& headers) OVERRIDE;
   virtual int OnHeadersReceived(
-      net::URLRequest* request,
-      const net::CompletionCallback& callback,
-      const net::HttpResponseHeaders* original_response_headers,
-      scoped_refptr<net::HttpResponseHeaders>* override_response_headers)
+      URLRequest* request,
+      const CompletionCallback& callback,
+      const HttpResponseHeaders* original_response_headers,
+      scoped_refptr<HttpResponseHeaders>* override_response_headers)
       OVERRIDE;

[wtc, 2012/11/12 21:50:49]

This may fit on the previous line now.

[jochen (gone - plz use gerrit), 2012/11/13 09:17:57]

Done.

-  virtual void OnBeforeRedirect(net::URLRequest* request,
+  virtual void OnBeforeRedirect(URLRequest* request,
                                 const GURL& new_location) OVERRIDE;
-  virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
-  virtual void OnRawBytesRead(const net::URLRequest& request,
+  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+  virtual void OnRawBytesRead(const URLRequest& request,
                               int bytes_read) OVERRIDE;
-  virtual void OnCompleted(net::URLRequest* request, bool started) OVERRIDE;
-  virtual void OnURLRequestDestroyed(net::URLRequest* request) OVERRIDE;
+  virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE;
+  virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE;
   virtual void OnPACScriptError(int line_number,
                                 const string16& error) OVERRIDE;
-  virtual net::NetworkDelegate::AuthRequiredResponse OnAuthRequired(
-      net::URLRequest* request,
-      const net::AuthChallengeInfo& auth_info,
+  virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
+      URLRequest* request,
+      const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
-      net::AuthCredentials* credentials) OVERRIDE;
-  virtual bool OnCanGetCookies(const net::URLRequest& request,
-                               const net::CookieList& cookie_list) OVERRIDE;
-  virtual bool OnCanSetCookie(const net::URLRequest& request,
+      AuthCredentials* credentials) OVERRIDE;
+  virtual bool OnCanGetCookies(const URLRequest& request,
+                               const CookieList& cookie_list) OVERRIDE;
+  virtual bool OnCanSetCookie(const URLRequest& request,
                               const std::string& cookie_line,
-                              net::CookieOptions* options) OVERRIDE;
-  virtual bool OnCanAccessFile(const net::URLRequest& request,
+                              CookieOptions* options) OVERRIDE;
+  virtual bool OnCanAccessFile(const URLRequest& request,
                                const FilePath& path) const OVERRIDE;
   virtual bool OnCanThrottleRequest(
-      const net::URLRequest& request) const OVERRIDE;
+      const URLRequest& request) const OVERRIDE;
   virtual int OnBeforeSocketStreamConnect(
-      net::SocketStream* stream,
-      const net::CompletionCallback& callback) OVERRIDE;
-  virtual void OnRequestWaitStateChange(const net::URLRequest& request,
+      SocketStream* stream,
+      const CompletionCallback& callback) OVERRIDE;
+  virtual void OnRequestWaitStateChange(const URLRequest& request,
                                         RequestWaitState state) OVERRIDE;
 
   void InitRequestStatesIfNew(int request_id);
 
   int last_error_;
   int error_count_;
   int created_requests_;
   int destroyed_requests_;
   int completed_requests_;
   int cookie_options_bit_mask_;
   int blocked_get_cookies_count_;
   int blocked_set_cookie_count_;
   int set_cookie_count_;
 
-  // net::NetworkDelegate callbacks happen in a particular order (e.g.
+  // NetworkDelegate callbacks happen in a particular order (e.g.
   // OnBeforeURLRequest is always called before OnBeforeSendHeaders).
   // This bit-set indicates for each request id (key) what events may be sent
   // next.
   std::map<int, int> next_states_;
 
   // A log that records for each request id (key) the order in which On...
   // functions were called.
   std::map<int, std::string> event_order_;
 };
 
@@ skipping 18 matching lines @@
   static std::string value_;
   const std::string old_value_;
   const std::string new_value_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedCustomUrlRequestTestHttpHost);
 };
 
 //-----------------------------------------------------------------------------
 
 // A simple Interceptor that returns a pre-built URLRequestJob only once.
-class TestJobInterceptor : public net::URLRequestJobFactory::Interceptor {
+class TestJobInterceptor : public URLRequestJobFactory::Interceptor {
  public:
   TestJobInterceptor();
 
-  virtual net::URLRequestJob* MaybeIntercept(
-      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE;
-  virtual net::URLRequestJob* MaybeInterceptRedirect(
+  virtual URLRequestJob* MaybeIntercept(
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual URLRequestJob* MaybeInterceptRedirect(
       const GURL& location,
-      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE;
-  virtual net::URLRequestJob* MaybeInterceptResponse(
-      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE;
-  void set_main_intercept_job(net::URLRequestJob* job);
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual URLRequestJob* MaybeInterceptResponse(
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const OVERRIDE;
+  void set_main_intercept_job(URLRequestJob* job);
 
  private:
-  mutable net::URLRequestJob* main_intercept_job_;
+  mutable URLRequestJob* main_intercept_job_;
 };
 
+}  // namespace net
+
 #endif  // NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_