NQE: Move ECT to net:: namespace

content/browser/loader/resource_loader_unittest.cc

 // Copyright (c) 2013 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 "content/browser/loader/resource_loader.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 24 matching lines @@
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_web_contents.h"
 #include "ipc/ipc_message.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mock_file_stream.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/cert/x509_certificate.h"
+#include "net/nqe/effective_connection_type.h"
 #include "net/nqe/network_quality_estimator.h"
 #include "net/ssl/client_cert_store.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_private_key.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/test_data_directory.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
@@ skipping 222 matching lines @@
         defer_request_on_will_start_(false),
         expect_reads_(true),
         cancel_on_read_completed_(false),
         defer_eof_(false),
         received_on_will_read_(false),
         received_eof_(false),
         received_response_completed_(false),
         received_request_redirected_(false),
         total_bytes_downloaded_(0),
         observed_effective_connection_type_(
-            net::NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {}
+            net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {}
 
   // If true, defers the resource load in OnWillStart.
   void set_defer_request_on_will_start(bool defer_request_on_will_start) {
     defer_request_on_will_start_ = defer_request_on_will_start;
   }
 
   // If true, expect OnWillRead / OnReadCompleted pairs for handling
   // data. Otherwise, expect OnDataDownloaded.
   void set_expect_reads(bool expect_reads) { expect_reads_ = expect_reads; }
 
@@ skipping 12 matching lines @@
   }
   bool received_response_completed() const {
     return received_response_completed_;
   }
   bool received_request_redirected() const {
     return received_request_redirected_;
   }
   const net::URLRequestStatus& status() const { return status_; }
   int total_bytes_downloaded() const { return total_bytes_downloaded_; }
 
-  net::NetworkQualityEstimator::EffectiveConnectionType
-  observed_effective_connection_type() const {
+  net::EffectiveConnectionType observed_effective_connection_type() const {
     return observed_effective_connection_type_;
   }
 
   void Resume() {
     controller()->Resume();
   }
 
   bool OnRequestRedirected(const net::RedirectInfo& redirect_info,
                            ResourceResponse* response,
                            bool* defer) override {
@@ skipping 96 matching lines @@
   scoped_refptr<ResourceResponse> redirect_response_;
   bool received_on_will_read_;
   bool received_eof_;
   bool received_response_completed_;
   bool received_request_redirected_;
   net::URLRequestStatus status_;
   int total_bytes_downloaded_;
   base::RunLoop deferred_run_loop_;
   base::RunLoop response_completed_run_loop_;
   std::unique_ptr<base::RunLoop> wait_for_progress_run_loop_;
-  net::NetworkQualityEstimator::EffectiveConnectionType
-      observed_effective_connection_type_;
+  net::EffectiveConnectionType observed_effective_connection_type_;
 };
 
 // Test browser client that captures calls to SelectClientCertificates and
 // records the arguments of the most recent call for later inspection.
 class SelectCertificateBrowserClient : public TestContentBrowserClient {
  public:
   SelectCertificateBrowserClient() : call_count_(0) {}
 
   // Waits until the first call to SelectClientCertificate.
   void WaitForSelectCertificate() {
@@ skipping 78 matching lines @@
                  base::Passed(std::unique_ptr<net::FileStream>()), nullptr));
 }
 
 }  // namespace
 
 class TestNetworkQualityEstimator : public net::NetworkQualityEstimator {
  public:
   TestNetworkQualityEstimator()
       : net::NetworkQualityEstimator(nullptr,
                                      std::map<std::string, std::string>()),
-        type_(net::NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {
-  }
+        type_(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {}
   ~TestNetworkQualityEstimator() override {}
 
-  net::NetworkQualityEstimator::EffectiveConnectionType
-  GetEffectiveConnectionType() const override {
+  net::EffectiveConnectionType GetEffectiveConnectionType() const override {
     return type_;
   }
 
-  void set_effective_connection_type(
-      net::NetworkQualityEstimator::EffectiveConnectionType type) {
+  void set_effective_connection_type(net::EffectiveConnectionType type) {
     type_ = type;
   }
 
  private:
-  net::NetworkQualityEstimator::EffectiveConnectionType type_;
+  net::EffectiveConnectionType type_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkQualityEstimator);
 };
 
 class ResourceLoaderTest : public testing::Test,
                            public ResourceLoaderDelegate {
  protected:
   ResourceLoaderTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         test_url_request_context_(true),
@@ skipping 620 matching lines @@
 
   EXPECT_EQ(kTestCertError, deserialized.cert_status);
   EXPECT_EQ(kTestConnectionStatus, deserialized.connection_status);
   EXPECT_EQ(kTestSecurityBits, deserialized.security_bits);
 }
 
 class EffectiveConnectionTypeResourceLoaderTest : public ResourceLoaderTest {
  public:
   void VerifyEffectiveConnectionType(
       bool is_main_frame,
-      net::NetworkQualityEstimator::EffectiveConnectionType set_type,
-      net::NetworkQualityEstimator::EffectiveConnectionType expected_type) {
+      net::EffectiveConnectionType set_type,
+      net::EffectiveConnectionType expected_type) {
     network_quality_estimator()->set_effective_connection_type(set_type);
 
     // Start the request and wait for it to finish.
     std::unique_ptr<net::URLRequest> request(
         resource_context_.GetRequestContext()->CreateRequest(
             test_url(), net::DEFAULT_PRIORITY, nullptr /* delegate */));
     SetUpResourceLoader(std::move(request), is_main_frame);
 
     // Send the request and wait until it completes.
     loader_->StartRequest();
     raw_ptr_resource_handler_->WaitForResponseComplete();
     ASSERT_EQ(net::URLRequestStatus::SUCCESS,
               raw_ptr_to_request_->status().status());
 
     EXPECT_EQ(expected_type,
               raw_ptr_resource_handler_->observed_effective_connection_type());
   }
 };
 
 // Tests that the effective connection type is set on main frame requests.
 TEST_F(EffectiveConnectionTypeResourceLoaderTest, Slow2G) {
-  VerifyEffectiveConnectionType(
-      true, net::NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G,
-      net::NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
+  VerifyEffectiveConnectionType(true, net::EFFECTIVE_CONNECTION_TYPE_SLOW_2G,
+                                net::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
 }
 
 // Tests that the effective connection type is set on main frame requests.
 TEST_F(EffectiveConnectionTypeResourceLoaderTest, 3G) {
-  VerifyEffectiveConnectionType(
-      true, net::NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G,
-      net::NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G);
+  VerifyEffectiveConnectionType(true, net::EFFECTIVE_CONNECTION_TYPE_3G,
+                                net::EFFECTIVE_CONNECTION_TYPE_3G);
 }
 
 // Tests that the effective connection type is not set on non-main frame
 // requests.
 TEST_F(EffectiveConnectionTypeResourceLoaderTest, NotAMainFrame) {
-  VerifyEffectiveConnectionType(
-      false, net::NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_3G,
-      net::NetworkQualityEstimator::EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
+  VerifyEffectiveConnectionType(false, net::EFFECTIVE_CONNECTION_TYPE_3G,
+                                net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
 }
 
 }  // namespace content