net: Remove typedef net::URLRequest URLRequest;

chrome/browser/chrome_plugin_host.cc

 // Copyright (c) 2010 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/chrome_plugin_host.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 36 matching lines @@
 #include "third_party/skia/include/core/SkBitmap.h"
 
 
 using base::TimeDelta;
 
 // This class manages the interception of network requests.  It queries the
 // plugin on every request, and creates an intercept job if the plugin can
 // intercept the request.
 // NOTE: All methods must be called on the IO thread.
 class PluginRequestInterceptor
-    : public PluginHelper, public URLRequest::Interceptor {
+    : public PluginHelper, public net::URLRequest::Interceptor {
  public:
   static URLRequestJob* UninterceptedProtocolHandler(
-      URLRequest* request, const std::string& scheme) {
+      net::URLRequest* request, const std::string& scheme) {
     // This will get called if a plugin failed to intercept a request for a
     // protocol it has registered.  In that case, we return NULL and the request
     // will result in an error.
     return new URLRequestErrorJob(request, net::ERR_FILE_NOT_FOUND);
   }
 
   explicit PluginRequestInterceptor(ChromePluginLib* plugin)
       : PluginHelper(plugin) {
-    URLRequest::RegisterRequestInterceptor(this);
+    net::URLRequest::RegisterRequestInterceptor(this);
   }
 
   virtual ~PluginRequestInterceptor() {
-    URLRequest::UnregisterRequestInterceptor(this);
+    net::URLRequest::UnregisterRequestInterceptor(this);
 
     // Unregister our protocols.
     for (HandledProtocolList::iterator it = registered_protocols_.begin();
          it != registered_protocols_.end(); ++it) {
-      URLRequest::ProtocolFactory* factory =
-          URLRequest::RegisterProtocolFactory(*it, NULL);
+      net::URLRequest::ProtocolFactory* factory =
+          net::URLRequest::RegisterProtocolFactory(*it, NULL);
       DCHECK(factory == UninterceptedProtocolHandler);
     }
   }
 
   void RegisterProtocol(const std::string& scheme) {
     DCHECK(CalledOnValidThread());
 
     std::string lower_scheme = StringToLowerASCII(scheme);
     handled_protocols_.insert(lower_scheme);
 
-    // Only add a protocol factory if the URLRequest doesn't already handle
+    // Only add a protocol factory if the net::URLRequest doesn't already handle
     // it.  If we fail to intercept, the request will be treated as an error.
-    if (!URLRequest::IsHandledProtocol(lower_scheme)) {
+    if (!net::URLRequest::IsHandledProtocol(lower_scheme)) {
       registered_protocols_.insert(lower_scheme);
-      URLRequest::RegisterProtocolFactory(lower_scheme,
+      net::URLRequest::RegisterProtocolFactory(lower_scheme,
                                           &UninterceptedProtocolHandler);
     }
   }
 
-  // URLRequest::Interceptor
-  virtual URLRequestJob* MaybeIntercept(URLRequest* request) {
+  // net::URLRequest::Interceptor
+  virtual URLRequestJob* MaybeIntercept(net::URLRequest* request) {
     // TODO(darin): This DCHECK fails in the unit tests because our interceptor
     // is being persisted across unit tests.  As a result, each time we get
     // poked on a different thread, but never from more than one thread at a
     // time.  We need a way to have the URLRequestJobManager get reset between
     // unit tests.
     // DCHECK(CalledOnValidThread());
 
     if (!IsHandledProtocol(request->url().scheme()))
       return NULL;
 
@@ skipping 25 matching lines @@
   void LogInterceptMissTime(const TimeDelta& time) {
     UMA_HISTOGRAM_TIMES("Gears.InterceptMiss", time);
   }
 
   typedef std::set<std::string> HandledProtocolList;
   HandledProtocolList handled_protocols_;
   HandledProtocolList registered_protocols_;
 };
 
 // This class manages a network request made by the plugin, also acting as
-// the URLRequest delegate.
+// the net::URLRequest delegate.
 // NOTE: All methods must be called on the IO thread.
-class PluginRequestHandler : public PluginHelper, public URLRequest::Delegate {
+class PluginRequestHandler : public PluginHelper,
+                             public net::URLRequest::Delegate {
  public:
   static PluginRequestHandler* FromCPRequest(CPRequest* request) {
     return ScopableCPRequest::GetData<PluginRequestHandler*>(request);
   }
 
   PluginRequestHandler(ChromePluginLib* plugin, ScopableCPRequest* cprequest)
       : PluginHelper(plugin), cprequest_(cprequest), user_buffer_(NULL) {
     cprequest_->data = this;  // see FromCPRequest().
 
     URLRequestContext* context = CPBrowsingContextManager::Instance()->
         ToURLRequestContext(cprequest_->context);
     // TODO(mpcomplete): remove fallback case when Gears support is prevalent.
     if (!context)
       context = Profile::GetDefaultRequestContext()->GetURLRequestContext();
 
     GURL gurl(cprequest_->url);
-    request_.reset(new URLRequest(gurl, this));
+    request_.reset(new net::URLRequest(gurl, this));
     request_->set_context(context);
     request_->set_method(cprequest_->method);
     request_->set_load_flags(PluginResponseUtils::CPLoadFlagsToNetFlags(0));
   }
 
-  URLRequest* request() { return request_.get(); }
+  net::URLRequest* request() { return request_.get(); }
 
-  // Wraper of URLRequest::Read()
+  // Wraper of net::URLRequest::Read()
   bool Read(char* dest, int dest_size, int *bytes_read) {
     CHECK(!my_buffer_.get());
     // We'll use our own buffer until the read actually completes.
     user_buffer_ = dest;
     my_buffer_ = new net::IOBuffer(dest_size);
 
     if (request_->Read(my_buffer_, dest_size, bytes_read)) {
       memcpy(dest, my_buffer_->data(), *bytes_read);
       my_buffer_ = NULL;
       return true;
     }
 
     if (!request_->status().is_io_pending())
       my_buffer_ = NULL;
 
     return false;
   }
 
-  // URLRequest::Delegate
-  virtual void OnReceivedRedirect(URLRequest* request, const GURL& new_url,
+  // net::URLRequest::Delegate
+  virtual void OnReceivedRedirect(net::URLRequest* request, const GURL& new_url,
                                   bool* defer_redirect) {
     plugin_->functions().response_funcs->received_redirect(
         cprequest_.get(), new_url.spec().c_str());
   }
 
-  virtual void OnResponseStarted(URLRequest* request) {
+  virtual void OnResponseStarted(net::URLRequest* request) {
     // TODO(mpcomplete): better error codes
     CPError result =
         request_->status().is_success() ? CPERR_SUCCESS : CPERR_FAILURE;
     plugin_->functions().response_funcs->start_completed(
         cprequest_.get(), result);
   }
 
-  virtual void OnReadCompleted(URLRequest* request, int bytes_read) {
+  virtual void OnReadCompleted(net::URLRequest* request, int bytes_read) {
     CHECK(my_buffer_.get());
     CHECK(user_buffer_);
     if (bytes_read > 0) {
       memcpy(user_buffer_, my_buffer_->data(), bytes_read);
     } else if (bytes_read < 0) {
       // TODO(mpcomplete): better error codes
       bytes_read = CPERR_FAILURE;
     }
     my_buffer_ = NULL;
     plugin_->functions().response_funcs->read_completed(
         cprequest_.get(), bytes_read);
   }
 
  private:
   scoped_ptr<ScopableCPRequest> cprequest_;
-  scoped_ptr<URLRequest> request_;
+  scoped_ptr<net::URLRequest> request_;
   scoped_refptr<net::IOBuffer> my_buffer_;
   char* user_buffer_;
 };
 
 // This class manages plugins that want to handle UI commands.  Right now, we
 // only allow 1 plugin to do this, so there's only ever 1 instance of this
 // class at once.
 // NOTE: All methods must be called on the IO thread.
 class PluginCommandHandler : public PluginHelper {
  public:
@@ skipping 590 matching lines @@
                      CPBrowsingContext context) {
   // Sadly if we try and pass context through, we seem to break cl's little
   // brain trying to compile the Tuple3 ctor. This cast works.
   int32 context_as_int32 = static_cast<int32>(context);
   // Plugins can only be accessed on the IO thread.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableFunction(PluginCommandHandler::HandleCommand,
                           command, data, context_as_int32));
 }