net: Remove typedef net::URLRequestStatus URLRequestStatus;

chrome_frame/urlmon_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/urlmon_url_request.h"
 
 #include <wininet.h>
 #include <urlmon.h>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 39 matching lines @@
   DCHECK(thread_ == 0 || thread_ == base::PlatformThread::CurrentId());
   thread_ = base::PlatformThread::CurrentId();
   status_.Start();
   // The UrlmonUrlRequest instance can get destroyed in the context of
   // StartAsyncDownload if BindToStorage finishes synchronously with an error.
   // Grab a reference to protect against this.
   scoped_refptr<UrlmonUrlRequest> ref(this);
   HRESULT hr = StartAsyncDownload();
   if (FAILED(hr) && status_.get_state() != UrlmonUrlRequest::Status::DONE) {
     status_.Done();
-    status_.set_result(URLRequestStatus::FAILED, HresultToNetError(hr));
+    status_.set_result(net::URLRequestStatus::FAILED, HresultToNetError(hr));
     NotifyDelegateAndDie();
   }
   return true;
 }
 
 void UrlmonUrlRequest::Stop() {
   DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DCHECK((status_.get_state() != Status::DONE) == (binding_ != NULL));
   Status::State state = status_.get_state();
   delegate_ = NULL;
@@ skipping 294 matching lines @@
   if (state == Status::WORKING) {
     status_.set_result(result);
 
     // Special case. If the last request was a redirect and the current OS
     // error value is E_ACCESSDENIED, that means an unsafe redirect was
     // attempted. In that case, correct the OS error value to be the more
     // specific ERR_UNSAFE_REDIRECT error value.
     if (result == E_ACCESSDENIED) {
       int http_code = GetHttpResponseStatusFromBinding(binding_);
       if (300 <= http_code && http_code < 400) {
-        status_.set_result(URLRequestStatus::FAILED,
-                          net::ERR_UNSAFE_REDIRECT);
+        status_.set_result(net::URLRequestStatus::FAILED,
+                           net::ERR_UNSAFE_REDIRECT);
       }
     }
 
     // The code below seems easy but it is not. :)
     // The network policy in Chrome network is that error code/end_of_stream
     // should be returned only as a result of read (or start) request.
     // Here are the possible cases:
     // pending_data_|pending_read
     //     FALSE  |FALSE   => EndRequest if no headers, otherwise wait for Read.
     //     FALSE  |TRUE    => EndRequest.
@@ skipping 443 matching lines @@
 
 void UrlmonUrlRequest::NotifyDelegateAndDie() {
   DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DVLOG(1) << __FUNCTION__ << me();
 
   PluginUrlRequestDelegate* delegate = delegate_;
   delegate_ = NULL;
   ReleaseBindings();
   TerminateTransaction();
   if (delegate) {
-    URLRequestStatus result = status_.get_result();
+    net::URLRequestStatus result = status_.get_result();
     delegate->OnResponseEnd(id(), result);
   } else {
     DLOG(WARNING) << __FUNCTION__ << me() << "no delegate";
   }
 }
 
 void UrlmonUrlRequest::TerminateTransaction() {
   if (cleanup_transaction_ && bind_context_ && moniker_) {
     // We return INET_E_TERMINATED_BIND from our OnDataAvailable implementation
     // to ensure that the transaction stays around if Chrome decides to issue
@@ skipping 128 matching lines @@
   scoped_refptr<UrlmonUrlRequest> new_request;
   bool is_started = false;
   if (pending_request_) {
     if (pending_request_->url() != request_info.url) {
       DLOG(WARNING) << __FUNCTION__
                     << "Received unexpected url request for url:"
                     << request_info.url
                     << ".Pending url request for url:"
                     << pending_request_->url()
                     << " was expected.";
-      URLRequestStatus result;
-      result.set_status(URLRequestStatus::FAILED);
+      net::URLRequestStatus result;
+      result.set_status(net::URLRequestStatus::FAILED);
       OnResponseEnd(request_id, result);
       return;
     }
     new_request.swap(pending_request_);
     is_started = true;
     DVLOG(1) << __FUNCTION__ << new_request->me()
              << " assigned id " << request_id;
   } else {
     CComObject<UrlmonUrlRequest>* created_request = NULL;
     CComObject<UrlmonUrlRequest>::CreateInstance(&created_request);
@@ skipping 166 matching lines @@
                                              const std::string& data) {
   DCHECK_NE(request_id, -1);
   DVLOG(1) << __FUNCTION__ << " id: " << request_id;
   DCHECK(LookupRequest(request_id) != NULL);
   ++calling_delegate_;
   delegate_->OnReadComplete(request_id, data);
   --calling_delegate_;
   DVLOG(1) << __FUNCTION__ << " done id: " << request_id;
 }
 
-void UrlmonUrlRequestManager::OnResponseEnd(int request_id,
-                                            const URLRequestStatus& status) {
+void UrlmonUrlRequestManager::OnResponseEnd(
+    int request_id,
+    const net::URLRequestStatus& status) {
   DCHECK_NE(request_id, -1);
   DVLOG(1) << __FUNCTION__;
-  DCHECK(status.status() != URLRequestStatus::CANCELED);
+  DCHECK(status.status() != net::URLRequestStatus::CANCELED);
   RequestMap::size_type n = request_map_.erase(request_id);
   if (n != 1u) {
     DLOG(WARNING) << __FUNCTION__
                   << " Failed to find request id:"
                   << request_id;
   }
   ++calling_delegate_;
   delegate_->OnResponseEnd(request_id, status);
   --calling_delegate_;
 }
@@ skipping 45 matching lines @@
       privacy_info_.privacy_records[UTF8ToWide(url)];
 
   privacy_entry.flags |= flags;
   privacy_entry.policy_ref = UTF8ToWide(policy_ref);
 
   if (fire_privacy_event && IsWindow(notification_window_)) {
     PostMessage(notification_window_, WM_FIRE_PRIVACY_CHANGE_NOTIFICATION, 1,
                 0);
   }
 }