net: Add namespace net to the remaining files under url_request directory.

chrome_frame/urlmon_url_request_private.h

-// 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.
 
 #ifndef CHROME_FRAME_URLMON_URL_REQUEST_PRIVATE_H_
 #define CHROME_FRAME_URLMON_URL_REQUEST_PRIVATE_H_
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <string>
 
@@ skipping 145 matching lines @@
     // Switch from [DONE] to [WORKING].
     void Start() {
       DCHECK_EQ(state_, DONE);
       state_ = WORKING;
     }
 
     // Save redirection information and switch to [ABORTING] state.
     // Assumes binding_->Abort() will be called!
     void SetRedirected(int http_code, const std::string& utf8_url) {
       DCHECK_EQ(state_, WORKING);
-      DCHECK_EQ(result_.status(), URLRequestStatus::SUCCESS);
+      DCHECK_EQ(result_.status(), net::URLRequestStatus::SUCCESS);
       redirect_.utf8_url = utf8_url;
 
       // At times we receive invalid redirect codes like 0, 200, etc. We
       // default to 302 in this case.
       redirect_.http_code = http_code;
       if (!net::HttpResponseHeaders::IsRedirectResponseCode(http_code))
         redirect_.http_code = 302;
 
       state_ = ABORTING;
     }
 
-    // Set the result as URLRequestStatus::CANCELED.
+    // Set the result as net::URLRequestStatus::CANCELED.
     // Switch to [ABORTING] state (if not already in that state).
     void Cancel() {
       if (state_ == DONE)
         return;
 
       if (state_ == WORKING) {
         state_ =  ABORTING;
       } else {
         // state_ == ABORTING
         redirect_.http_code = 0;
         redirect_.utf8_url.clear();
       }
 
-      set_result(URLRequestStatus::CANCELED, 0);
+      set_result(net::URLRequestStatus::CANCELED, 0);
     }
 
     void Done() {
       state_ = DONE;
     }
 
     bool was_redirected() const {
       return redirect_.http_code != 0;
     }
 
     const Redirection& get_redirection() const {
       return redirect_;
     }
 
-    const URLRequestStatus& get_result() const {
+    const net::URLRequestStatus& get_result() const {
       return result_;
     }
 
-    void set_result(URLRequestStatus::Status status, int os_error) {
+    void set_result(net::URLRequestStatus::Status status, int os_error) {
       result_.set_status(status);
       result_.set_os_error(os_error);
     }
 
     void set_result(HRESULT hr) {
-      result_.set_status(FAILED(hr)? URLRequestStatus::FAILED:
-                                     URLRequestStatus::SUCCESS);
+      result_.set_status(FAILED(hr)? net::URLRequestStatus::FAILED:
+                                     net::URLRequestStatus::SUCCESS);
       result_.set_os_error(HresultToNetError(hr));
     }
 
    private:
     Redirection redirect_;
     State state_;
-    URLRequestStatus result_;
+    net::URLRequestStatus result_;
   };
 
   Status status_;
   ScopedComPtr<IBinding> binding_;
   ScopedComPtr<IMoniker> moniker_;
   ScopedComPtr<IBindCtx> bind_context_;
   ScopedComPtr<IStream> cache_;
   ScopedComPtr<IStream> pending_data_;
 
   size_t pending_read_size_;
@@ skipping 12 matching lines @@
   bool is_expecting_download_;
   // Set to true if the Urlmon transaction object needs to be cleaned up
   // when this object is destroyed. Happens if we return
   // INET_E_TERMINATE_BIND from OnDataAvailable in the last data notification.
   bool cleanup_transaction_;
 
   DISALLOW_COPY_AND_ASSIGN(UrlmonUrlRequest);
 };
 
 #endif  // CHROME_FRAME_URLMON_URL_REQUEST_PRIVATE_H_