net: Remove typedef net::URLRequestStatus URLRequestStatus;

chrome_frame/npapi_url_request.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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_frame/npapi_url_request.h"
 
 #include "base/string_number_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "chrome_frame/np_browser_functions.h"
 #include "chrome_frame/np_utils.h"
 #include "net/base/net_errors.h"
@@ skipping 11 matching lines @@
   NPError OnStreamCreated(const char* mime_type, NPStream* stream);
   NPError OnStreamDestroyed(NPReason reason);
   int OnWriteReady();
   int OnWrite(void* buffer, int len);
 
   // Thread unsafe implementation of ref counting, since
   // this will be called on the plugin UI thread only.
   virtual unsigned long API_CALL AddRef();
   virtual unsigned long API_CALL Release();
 
-  const URLRequestStatus& status() const {
+  const net::URLRequestStatus& status() const {
     return status_;
   }
 
   NPP instance() const {
     return instance_;
   }
 
  private:
   unsigned long ref_count_;
   NPP instance_;
   NPStream* stream_;
   size_t pending_read_size_;
-  URLRequestStatus status_;
+  net::URLRequestStatus status_;
 
   base::PlatformThreadId thread_;
   static int instance_count_;
   DISALLOW_COPY_AND_ASSIGN(NPAPIUrlRequest);
 };
 
 int NPAPIUrlRequest::instance_count_ = 0;
 
 NPAPIUrlRequest::NPAPIUrlRequest(NPP instance)
     : ref_count_(0), instance_(instance), stream_(NULL),
       pending_read_size_(0),
-      status_(URLRequestStatus::FAILED, net::ERR_FAILED),
+      status_(net::URLRequestStatus::FAILED, net::ERR_FAILED),
       thread_(base::PlatformThread::CurrentId()) {
   DVLOG(1) << "Created request. Count: " << ++instance_count_;
 }
 
 NPAPIUrlRequest::~NPAPIUrlRequest() {
   DVLOG(1) << "Deleted request. Count: " << --instance_count_;
 }
 
 // NPAPIUrlRequest member defines.
 bool NPAPIUrlRequest::Start() {
@@ skipping 36 matching lines @@
     int os_error = net::ERR_FAILED;
     switch (result) {
       case NPERR_INVALID_URL:
         os_error = net::ERR_INVALID_URL;
         break;
       default:
         break;
     }
 
     delegate_->OnResponseEnd(id(),
-        URLRequestStatus(URLRequestStatus::FAILED, os_error));
+        net::URLRequestStatus(net::URLRequestStatus::FAILED, os_error));
     return false;
   }
 
   return true;
 }
 
 void NPAPIUrlRequest::Stop() {
   DVLOG(1) << "Finished request: Url - " << url()
            << " result: " << static_cast<int>(status_.status());
 
-  status_.set_status(URLRequestStatus::CANCELED);
+  status_.set_status(net::URLRequestStatus::CANCELED);
   if (stream_) {
     npapi::DestroyStream(instance_, stream_, NPRES_USER_BREAK);
     stream_ = NULL;
   }
 }
 
 bool NPAPIUrlRequest::Read(int bytes_to_read) {
   pending_read_size_ = bytes_to_read;
   return true;
 }
 
 NPError NPAPIUrlRequest::OnStreamCreated(const char* mime_type,
                                          NPStream* stream) {
   stream_ = stream;
-  status_.set_status(URLRequestStatus::IO_PENDING);
+  status_.set_status(net::URLRequestStatus::IO_PENDING);
   // TODO(iyengar)
   // Add support for passing persistent cookies and information about any URL
   // redirects to Chrome.
   delegate_->OnResponseStarted(id(), mime_type, stream->headers, stream->end,
       base::Time::FromTimeT(stream->lastmodified), std::string(), 0);
   return NPERR_NO_ERROR;
 }
 
 NPError NPAPIUrlRequest::OnStreamDestroyed(NPReason reason) {
   // If the request has been aborted, then ignore the |reason| argument.
   // Normally the execution flow is such than NPRES_USER_BREAK will be passed
   // when the stream is aborted, but sometimes NPRES_NETWORK_ERROR is passed
   // instead.  To prevent Chrome from receiving a notification of a failed
   // network connection, when Chrome actually canceled the request, we ignore
   // the status here.
-  if (URLRequestStatus::CANCELED != status_.status()) {
+  if (net::URLRequestStatus::CANCELED != status_.status()) {
     switch (reason) {
       case NPRES_DONE:
-        status_.set_status(URLRequestStatus::SUCCESS);
+        status_.set_status(net::URLRequestStatus::SUCCESS);
         status_.set_os_error(0);
         break;
       case NPRES_USER_BREAK:
-        status_.set_status(URLRequestStatus::CANCELED);
+        status_.set_status(net::URLRequestStatus::CANCELED);
         status_.set_os_error(net::ERR_ABORTED);
         break;
       case NPRES_NETWORK_ERR:
       default:
-        status_.set_status(URLRequestStatus::FAILED);
+        status_.set_status(net::URLRequestStatus::FAILED);
         status_.set_os_error(net::ERR_CONNECTION_CLOSED);
         break;
     }
   }
 
   delegate_->OnResponseEnd(id(), status_);
   return NPERR_NO_ERROR;
 }
 
 int NPAPIUrlRequest::OnWriteReady() {
@@ skipping 147 matching lines @@
     int redirect_status) {
   delegate_->OnResponseStarted(request_id, mime_type, headers, size,
       last_modified, redirect_url, redirect_status);
 }
 
 void NPAPIUrlRequestManager::OnReadComplete(int request_id,
                                             const std::string& data) {
   delegate_->OnReadComplete(request_id, data);
 }
 
-void NPAPIUrlRequestManager::OnResponseEnd(int request_id,
-                                           const URLRequestStatus& status) {
+void NPAPIUrlRequestManager::OnResponseEnd(
+    int request_id,
+    const net::URLRequestStatus& status) {
   // Delete from map.
   RequestMap::iterator it = request_map_.find(request_id);
   DCHECK(request_map_.end() != it);
   scoped_refptr<NPAPIUrlRequest> request = (*it).second;
   request_map_.erase(it);
 
   // Inform delegate unless canceled.
-  if (status.status() != URLRequestStatus::CANCELED)
+  if (status.status() != net::URLRequestStatus::CANCELED)
     delegate_->OnResponseEnd(request_id, status);
 }
 
 void NPAPIUrlRequestManager::OnCookiesRetrieved(bool success, const GURL& url,
     const std::string& cookie_string, int cookie_id) {
   delegate_->OnCookiesRetrieved(success, url, cookie_string, cookie_id);
 }
 
 // Notifications from browser. Find the NPAPIUrlRequest and forward to it.
 NPError NPAPIUrlRequestManager::NewStream(NPMIMEType type,
                                           NPStream* stream,
                                           NPBool seekable,
                                           uint16* stream_type) {
   NPAPIUrlRequest* request = RequestFromNotifyData(stream->notifyData);
   if (!request)
     return NPERR_NO_ERROR;
 
   // This stream is being constructed for a request that has already been
   // canceled.  Signal its immediate termination.
-  if (URLRequestStatus::CANCELED == request->status().status()) {
+  if (net::URLRequestStatus::CANCELED == request->status().status()) {
     return npapi::DestroyStream(request->instance(),
                                 stream, NPRES_USER_BREAK);
   }
 
   DCHECK(request_map_.find(request->id()) != request_map_.end());
   // We need to return the requested stream mode if we are returning a success
   // code. If we don't do this it causes Opera to blow up.
   *stream_type = NP_NORMAL;
   return request->OnStreamCreated(type, stream);
 }
@@ skipping 41 matching lines @@
   }
 }
 
 scoped_refptr<NPAPIUrlRequest> NPAPIUrlRequestManager::LookupRequest(
     int request_id) {
   RequestMap::iterator index = request_map_.find(request_id);
   if (index != request_map_.end())
     return index->second;
   return NULL;
 }