[Android WebView] Put AndroidStreamReaderURLRequestJob into a namespace

android_webview/browser/net/android_stream_reader_url_request_job.cc

 // 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.
 
 #include "android_webview/browser/net/android_stream_reader_url_request_job.h"
 
 #include <string>
 
 #include "android_webview/browser/input_stream.h"
 #include "android_webview/browser/net/input_stream_reader.h"
@@ skipping 11 matching lines @@
 #include "net/base/io_buffer.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job_manager.h"
 
-using android_webview::InputStream;
-using android_webview::InputStreamReader;
 using base::android::AttachCurrentThread;
 using base::PostTaskAndReplyWithResult;
 using content::BrowserThread;
 
+namespace android_webview {
+
 namespace {
 
 const int kHTTPOk = 200;
 const int kHTTPNotFound = 404;
 
 const char kResponseHeaderViaShouldInterceptRequest[] =
     "Client-Via: shouldInterceptRequest";
 const char kHTTPOkText[] = "OK";
 const char kHTTPNotFoundText[] = "Not Found";
 
 } // namespace
 
 // The requests posted to the worker thread might outlive the job.  Thread-safe
 // ref counting is used to ensure that the InputStream and InputStreamReader
 // members of this class are still there when the closure is run on the worker
 // thread.
 class InputStreamReaderWrapper :
     public base::RefCountedThreadSafe<InputStreamReaderWrapper> {
  public:
   InputStreamReaderWrapper(
       scoped_ptr<InputStream> input_stream,
       scoped_ptr<InputStreamReader> input_stream_reader)
       : input_stream_(input_stream.Pass()),
         input_stream_reader_(input_stream_reader.Pass()) {
     DCHECK(input_stream_);
     DCHECK(input_stream_reader_);
   }
 
-  android_webview::InputStream* input_stream() {
+  InputStream* input_stream() {
     return input_stream_.get();
   }
 
   int Seek(const net::HttpByteRange& byte_range) {
     return input_stream_reader_->Seek(byte_range);
   }
 
   int ReadRawData(net::IOBuffer* buffer, int buffer_size) {
     return input_stream_reader_->ReadRawData(buffer, buffer_size);
   }
 
  private:
   friend class base::RefCountedThreadSafe<InputStreamReaderWrapper>;
   ~InputStreamReaderWrapper() {}
 
-  scoped_ptr<android_webview::InputStream> input_stream_;
-  scoped_ptr<android_webview::InputStreamReader> input_stream_reader_;
+  scoped_ptr<InputStream> input_stream_;
+  scoped_ptr<InputStreamReader> input_stream_reader_;
 
   DISALLOW_COPY_AND_ASSIGN(InputStreamReaderWrapper);
 };
 
 AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     scoped_ptr<Delegate> delegate)
     : URLRequestJob(request, network_delegate),
       delegate_(delegate.Pass()),
@@ skipping 264 matching lines @@
       } else {
         // We don't support multiple range requests in one single URL request,
         // because we need to do multipart encoding here.
         NotifyDone(net::URLRequestStatus(
             net::URLRequestStatus::FAILED,
             net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
       }
     }
   }
 }
+
+}  // namespace android_webview