Remove net:: in spdy_network_transaction_unittest.

net/spdy/spdy_network_transaction_unittest.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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
@@ skipping 208 matching lines @@
       output_.rv = trans_->Start(&request_, callback_.callback(), log_);
 
       // We expect an IO Pending or some sort of error.
       EXPECT_LT(output_.rv, 0);
       return output_.rv == ERR_IO_PENDING;
     }
 
     void FinishDefaultTest() {
       output_.rv = callback_.WaitForResult();
       if (output_.rv != OK) {
-        session_->spdy_session_pool()->CloseCurrentSessions(net::ERR_ABORTED);
+        session_->spdy_session_pool()->CloseCurrentSessions(ERR_ABORTED);
         return;
       }
 
       // Verify responses.
       const HttpResponseInfo* response = trans_->GetResponseInfo();
       ASSERT_TRUE(response != NULL);
       ASSERT_TRUE(response->headers.get() != NULL);
       EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
       EXPECT_EQ(spdy_enabled_, response->was_fetched_via_spdy);
       if (HttpStreamFactory::spdy_enabled()) {
@@ skipping 19 matching lines @@
       EXPECT_EQ("127.0.0.1", response->socket_address.host());
       EXPECT_EQ(port_, response->socket_address.port());
       output_.status_line = response->headers->GetStatusLine();
       output_.response_info = *response;  // Make a copy so we can verify.
       output_.rv = ReadTransaction(trans_.get(), &output_.response_data);
     }
 
     void FinishDefaultTestWithoutVerification() {
       output_.rv = callback_.WaitForResult();
       if (output_.rv != OK)
-        session_->spdy_session_pool()->CloseCurrentSessions(net::ERR_ABORTED);
+        session_->spdy_session_pool()->CloseCurrentSessions(ERR_ABORTED);
     }
 
     // Most tests will want to call this function. In particular, the MockReads
     // should end with an empty read, and that read needs to be processed to
     // ensure proper deletion of the spdy_session_pool.
     void VerifyDataConsumed() {
       for (DataVector::iterator it = data_vector_.begin();
           it != data_vector_.end(); ++it) {
         EXPECT_TRUE((*it)->at_read_eof()) << "Read count: "
                                           << (*it)->read_count()
@@ skipping 294 matching lines @@
   // Read the result of a particular transaction, knowing that we've got
   // multiple transactions in the read pipeline; so as we read, we may have
   // to skip over data destined for other transactions while we consume
   // the data for |trans|.
   int ReadResult(HttpNetworkTransaction* trans,
                  StaticSocketDataProvider* data,
                  std::string* result) {
     const int kSize = 3000;
 
     int bytes_read = 0;
-    scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(kSize));
+    scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(kSize));
     TestCompletionCallback callback;
     while (true) {
       int rv = trans->Read(buf.get(), kSize, callback.callback());
       if (rv == ERR_IO_PENDING) {
         // Multiple transactions may be in the data set.  Keep pulling off
         // reads until we complete our callback.
         while (!callback.have_result()) {
           data->CompleteRead();
           base::RunLoop().RunUntilIdle();
         }
@@ skipping 1773 matching lines @@
   helper.AddData(&data2);
   HttpNetworkTransaction* trans = helper.trans();
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   const int kSize = 3000;
-  scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
+  scoped_refptr<IOBuffer> buf(new IOBuffer(kSize));
   rv = trans->Read(
       buf.get(),
       kSize,
       base::Bind(&SpdyNetworkTransactionTest::StartTransactionCallback,
                  helper.session()));
   // This forces an err_IO_pending, which sets the callback.
   data.CompleteRead();
   // This finishes the read.
   data.CompleteRead();
   helper.VerifyDataConsumed();
@@ skipping 27 matching lines @@
 
   // Start the transaction with basic parameters.
   TestCompletionCallback callback;
   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   // Setup a user callback which will delete the session, and clear out the
   // memory holding the stream object. Note that the callback deletes trans.
   const int kSize = 3000;
-  scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
+  scoped_refptr<IOBuffer> buf(new IOBuffer(kSize));
   rv = trans->Read(
       buf.get(),
       kSize,
       base::Bind(&SpdyNetworkTransactionTest::DeleteSessionCallback,
                  base::Unretained(&helper)));
   ASSERT_EQ(ERR_IO_PENDING, rv);
   data.CompleteRead();
 
   // Finish running rest of tasks.
   base::RunLoop().RunUntilIdle();
@@ skipping 61 matching lines @@
     d.set_quit_on_redirect(true);
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
 
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     std::string contents("hello!");
     EXPECT_EQ(contents, d.data_received());
   }
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
   EXPECT_TRUE(data2.at_read_eof());
   EXPECT_TRUE(data2.at_write_eof());
 }
 
 // Send a spdy request to www.google.com. Get a pushed stream that redirects to
@@ skipping 87 matching lines @@
 
     d2.set_quit_on_redirect(true);
     r2->Start();
     base::RunLoop().Run();
     EXPECT_EQ(1, d2.received_redirect_count());
 
     r2->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d2.response_started_count());
     EXPECT_FALSE(d2.received_data_before_response());
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, r2->status().status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r2->status().status());
     std::string contents2("hello!");
     EXPECT_EQ(contents2, d2.data_received());
   }
   data.CompleteRead();
   data2.CompleteRead();
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
   EXPECT_TRUE(data2.at_read_eof());
   EXPECT_TRUE(data2.at_write_eof());
 }
@@ skipping 1120 matching lines @@
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   // Check that the NetLog was filled reasonably.
   // This test is intentionally non-specific about the exact ordering of the
   // log; instead we just check to make sure that certain events exist, and that
   // they are in the right order.
-  net::CapturingNetLog::CapturedEntryList entries;
+  CapturingNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_LT(0u, entries.size());
   int pos = 0;
-  pos = net::ExpectLogContainsSomewhere(entries, 0,
-      net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
-      net::NetLog::PHASE_BEGIN);
-  pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
-      net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
-      net::NetLog::PHASE_END);
-  pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
-      net::NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
-      net::NetLog::PHASE_BEGIN);
-  pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
-      net::NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
-      net::NetLog::PHASE_END);
-  pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
-      net::NetLog::TYPE_HTTP_TRANSACTION_READ_BODY,
-      net::NetLog::PHASE_BEGIN);
-  pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
-      net::NetLog::TYPE_HTTP_TRANSACTION_READ_BODY,
-      net::NetLog::PHASE_END);
+  pos = ExpectLogContainsSomewhere(entries, 0,
+                                   NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
+                                   NetLog::PHASE_BEGIN);
+  pos = ExpectLogContainsSomewhere(entries, pos + 1,
+                                   NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
+                                   NetLog::PHASE_END);
+  pos = ExpectLogContainsSomewhere(entries, pos + 1,
+                                   NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
+                                   NetLog::PHASE_BEGIN);
+  pos = ExpectLogContainsSomewhere(entries, pos + 1,
+                                   NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
+                                   NetLog::PHASE_END);
+  pos = ExpectLogContainsSomewhere(entries, pos + 1,
+                                   NetLog::TYPE_HTTP_TRANSACTION_READ_BODY,
+                                   NetLog::PHASE_BEGIN);
+  pos = ExpectLogContainsSomewhere(entries, pos + 1,
+                                   NetLog::TYPE_HTTP_TRANSACTION_READ_BODY,
+                                   NetLog::PHASE_END);
 
   // Check that we logged all the headers correctly
-  const NetLog::EventType type =
-      (GetParam().protocol <= kProtoSPDY31)
-          ? net::NetLog::TYPE_HTTP2_SESSION_SYN_STREAM
-          : net::NetLog::TYPE_HTTP2_SESSION_SEND_HEADERS;
-  pos = net::ExpectLogContainsSomewhere(entries, 0, type,
-                                        net::NetLog::PHASE_NONE);
+  const NetLog::EventType type = (GetParam().protocol <= kProtoSPDY31)
+                                     ? NetLog::TYPE_HTTP2_SESSION_SYN_STREAM
+                                     : NetLog::TYPE_HTTP2_SESSION_SEND_HEADERS;
+  pos = ExpectLogContainsSomewhere(entries, 0, type, NetLog::PHASE_NONE);
 
   base::ListValue* header_list;
   ASSERT_TRUE(entries[pos].params.get());
   ASSERT_TRUE(entries[pos].params->GetList("headers", &header_list));
 
   std::vector<std::string> expected;
   expected.push_back(std::string(spdy_util_.GetHostKey()) + ": www.google.com");
   expected.push_back(std::string(spdy_util_.GetPathKey()) + ": /");
   expected.push_back(std::string(spdy_util_.GetSchemeKey()) + ": http");
   expected.push_back(std::string(spdy_util_.GetMethodKey()) + ": GET");
@@ skipping 73 matching lines @@
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   std::string content;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 3;
-    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
+    scoped_refptr<IOBuffer> buf(new IOBuffer(kSmallReadSize));
     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
-    if (rv == net::ERR_IO_PENDING) {
+    if (rv == ERR_IO_PENDING) {
       data.CompleteRead();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       NOTREACHED();
     }
   } while (rv > 0);
 
@@ skipping 70 matching lines @@
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   std::string content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
-    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
+    scoped_refptr<IOBuffer> buf(new IOBuffer(kSmallReadSize));
     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
-    if (rv == net::ERR_IO_PENDING) {
+    if (rv == ERR_IO_PENDING) {
       data.CompleteRead();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
       EXPECT_EQ(kSmallReadSize, rv);
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       FAIL() << "Unexpected read error: " << rv;
     }
     reads_completed++;
@@ skipping 66 matching lines @@
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   std::string content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
-    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
+    scoped_refptr<IOBuffer> buf(new IOBuffer(kSmallReadSize));
     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
     if (rv > 0) {
       EXPECT_EQ(kSmallReadSize, rv);
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       FAIL() << "Unexpected read error: " << rv;
     }
     reads_completed++;
   } while (rv > 0);
 
@@ skipping 69 matching lines @@
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   std::string content;
   int reads_completed = 0;
   do {
     // Read small chunks at a time.
     const int kSmallReadSize = 14;
-    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
+    scoped_refptr<IOBuffer> buf(new IOBuffer(kSmallReadSize));
     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
-    if (rv == net::ERR_IO_PENDING) {
+    if (rv == ERR_IO_PENDING) {
       data.CompleteRead();
       rv = read_callback.WaitForResult();
     }
     if (rv > 0) {
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       // This test intentionally closes the connection, and will get an error.
       EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
       break;
     }
@@ skipping 55 matching lines @@
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
 
   // Read Data
   TestCompletionCallback read_callback;
 
   const int kReadSize = 256;
-  scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kReadSize));
+  scoped_refptr<IOBuffer> buf(new IOBuffer(kReadSize));
   rv = trans->Read(buf.get(), kReadSize, read_callback.callback());
-  ASSERT_EQ(net::ERR_IO_PENDING, rv) << "Unexpected read: " << rv;
+  ASSERT_EQ(ERR_IO_PENDING, rv) << "Unexpected read: " << rv;
 
   // Complete the read now, which causes buffering to start.
   data.CompleteRead();
   // Destroy the transaction, causing the stream to get cancelled
   // and orphaning the buffered IO task.
   helper.ResetTrans();
 
   // Flush the MessageLoop; this will cause the buffered IO task
   // to run for the final time.
   base::RunLoop().RunUntilIdle();
@@ skipping 783 matching lines @@
   request_proxy.url = GURL("http://www.google.com/foo.dat");
   request_proxy.load_flags = 0;
   scoped_ptr<SpdySessionDependencies> ssd_proxy(
       CreateSpdySessionDependencies(GetParam()));
   // Ensure that this transaction uses the same SpdySessionPool.
   scoped_refptr<HttpNetworkSession> session_proxy(
       SpdySessionDependencies::SpdyCreateSession(ssd_proxy.get()));
   NormalSpdyTransactionHelper helper_proxy(request_proxy, DEFAULT_PRIORITY,
                                            BoundNetLog(), GetParam(), NULL);
   HttpNetworkSessionPeer session_peer(session_proxy);
-  scoped_ptr<net::ProxyService> proxy_service(
-          ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
+  scoped_ptr<ProxyService> proxy_service(
+      ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
   session_peer.SetProxyService(proxy_service.get());
   helper_proxy.session_deps().swap(ssd_proxy);
   helper_proxy.SetSession(session_proxy);
   helper_proxy.RunPreTestSetup();
   helper_proxy.AddData(data_proxy.get());
 
   HttpNetworkTransaction* trans_proxy = helper_proxy.trans();
   TestCompletionCallback callback_proxy;
   int rv = trans_proxy->Start(
       &request_proxy, callback_proxy.callback(), BoundNetLog());
@@ skipping 112 matching lines @@
   DelayedSocketData data(1, spdy_reads, arraysize(spdy_reads),
                          spdy_writes, arraysize(spdy_writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
-  net::HttpStreamFactory::set_spdy_enabled(false);
+  HttpStreamFactory::set_spdy_enabled(false);
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello from http"),
     MockRead(SYNCHRONOUS, OK),
   };
   DelayedSocketData data2(1, http_reads, arraysize(http_reads), NULL, 0);
   NormalSpdyTransactionHelper helper2(CreateGetRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper2.SetSpdyDisabled();
   helper2.RunToCompletion(&data2);
   TransactionHelperResult out2 = helper2.output();
   EXPECT_EQ(OK, out2.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out2.status_line);
   EXPECT_EQ("hello from http", out2.response_data);
 
-  net::HttpStreamFactory::set_spdy_enabled(true);
+  HttpStreamFactory::set_spdy_enabled(true);
 }
 
 // Tests that Basic authentication works over SPDY
 TEST_P(SpdyNetworkTransactionTest, SpdyBasicAuth) {
-  net::HttpStreamFactory::set_spdy_enabled(true);
+  HttpStreamFactory::set_spdy_enabled(true);
 
   // The first request will be a bare GET, the second request will be a
   // GET with an Authorization header.
   scoped_ptr<SpdyFrame> req_get(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   const char* const kExtraAuthorizationHeaders[] = {
     "authorization", "Basic Zm9vOmJhcg=="
   };
   scoped_ptr<SpdyFrame> req_get_authorization(
       spdy_util_.ConstructSpdyGet(kExtraAuthorizationHeaders,
@@ skipping 1014 matching lines @@
             stream->stream()->recv_window_size());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
 
   // Issue a read which will cause a WINDOW_UPDATE to be sent and window
   // size increased to default.
-  scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kTargetSize));
+  scoped_refptr<IOBuffer> buf(new IOBuffer(kTargetSize));
   EXPECT_EQ(static_cast<int>(kTargetSize),
             trans->Read(buf.get(), kTargetSize, CompletionCallback()));
   EXPECT_EQ(static_cast<int>(initial_window_size),
             stream->stream()->recv_window_size());
   EXPECT_THAT(base::StringPiece(buf->data(), kTargetSize), Each(Eq('x')));
 
   // Allow scheduled WINDOW_UPDATE frames to write.
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
 }
@@ skipping 584 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   scoped_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(ssl_provider.Pass());
 }
 
 }  // namespace net