Update Effective Connection Type only on main frame requests

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 10 matching lines @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/loader/redirect_to_file_resource_handler.h"
 #include "content/browser/loader/resource_loader_delegate.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/public/browser/cert_store.h"
 #include "content/public/browser/client_certificate_delegate.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/resource_response.h"
+#include "content/public/common/resource_type.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_renderer_host.h"
 #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"
@@ skipping 541 matching lines @@
   }
 
   virtual std::unique_ptr<ResourceHandler> WrapResourceHandler(
       std::unique_ptr<ResourceHandlerStub> leaf_handler,
       net::URLRequest* request) {
     return std::move(leaf_handler);
   }
 
   // Replaces loader_ with a new one for |request|.
   void SetUpResourceLoader(std::unique_ptr<net::URLRequest> request,
-                           bool is_main_frame) {
+                           ResourceType resource_type,
+                           bool belongs_to_main_frame) {
     raw_ptr_to_request_ = request.get();
 
-    ResourceType resource_type =
-        is_main_frame ? RESOURCE_TYPE_MAIN_FRAME : RESOURCE_TYPE_SUB_FRAME;
+    // A request marked as a main frame request must also belong to a main
+    // frame.
+    ASSERT_TRUE((resource_type != RESOURCE_TYPE_MAIN_FRAME) ||
+                belongs_to_main_frame);
 
     RenderFrameHost* rfh = web_contents_->GetMainFrame();
     ResourceRequestInfo::AllocateForTesting(
         request.get(), resource_type, &resource_context_,
         rfh->GetProcess()->GetID(), rfh->GetRenderViewHost()->GetRoutingID(),
-        rfh->GetRoutingID(), is_main_frame, false /* parent_is_main_frame */,
-        true /* allow_download */, false /* is_async */,
-        false /* is_using_lofi_ */);
+        rfh->GetRoutingID(), belongs_to_main_frame,
+        false /* parent_is_main_frame */, true /* allow_download */,
+        false /* is_async */, false /* is_using_lofi_ */);
     std::unique_ptr<ResourceHandlerStub> resource_handler(
         new ResourceHandlerStub(request.get()));
     raw_ptr_resource_handler_ = resource_handler.get();
     loader_.reset(new ResourceLoader(
         std::move(request),
         WrapResourceHandler(std::move(resource_handler), raw_ptr_to_request_),
         CertStore::GetInstance(), this));
   }
 
   void SetUp() override {
     job_factory_.SetProtocolHandler("test", CreateProtocolHandler());
 
     browser_context_.reset(new TestBrowserContext());
     scoped_refptr<SiteInstance> site_instance =
         SiteInstance::Create(browser_context_.get());
     web_contents_.reset(
         TestWebContents::Create(browser_context_.get(), site_instance.get()));
 
     std::unique_ptr<net::URLRequest> request(
         resource_context_.GetRequestContext()->CreateRequest(
             test_url(), net::DEFAULT_PRIORITY, nullptr /* delegate */));
-    SetUpResourceLoader(std::move(request), true);
+    SetUpResourceLoader(std::move(request), RESOURCE_TYPE_MAIN_FRAME, true);
   }
 
   void TearDown() override {
     // Destroy the WebContents and pump the event loop before destroying
     // |rvh_test_enabler_| and |thread_bundle_|. This lets asynchronous cleanup
     // tasks complete.
     web_contents_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
@@ skipping 468 matching lines @@
   EXPECT_EQ(test_data(), contents);
 }
 
 // Test that an HTTPS resource has the expected security info attached
 // to it.
 TEST_F(HTTPSSecurityInfoResourceLoaderTest, SecurityInfoOnHTTPSResource) {
   // Start the request and wait for it to finish.
   std::unique_ptr<net::URLRequest> request(
       resource_context_.GetRequestContext()->CreateRequest(
           test_https_url(), net::DEFAULT_PRIORITY, nullptr /* delegate */));
-  SetUpResourceLoader(std::move(request), true);
+  SetUpResourceLoader(std::move(request), RESOURCE_TYPE_MAIN_FRAME, true);
 
   // 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());
 
   ResourceResponse* response = raw_ptr_resource_handler_->response();
   ASSERT_TRUE(response);
 
@@ skipping 18 matching lines @@
 
 // Test that an HTTPS redirect response has the expected security info
 // attached to it.
 TEST_F(HTTPSSecurityInfoResourceLoaderTest,
        SecurityInfoOnHTTPSRedirectResource) {
   // Start the request and wait for it to finish.
   std::unique_ptr<net::URLRequest> request(
       resource_context_.GetRequestContext()->CreateRequest(
           test_https_redirect_url(), net::DEFAULT_PRIORITY,
           nullptr /* delegate */));
-  SetUpResourceLoader(std::move(request), true);
+  SetUpResourceLoader(std::move(request), RESOURCE_TYPE_MAIN_FRAME, true);
 
   // 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());
   ASSERT_TRUE(raw_ptr_resource_handler_->received_request_redirected());
 
   ResourceResponse* redirect_response =
       raw_ptr_resource_handler_->redirect_response();
@@ skipping 14 matching lines @@
   EXPECT_TRUE(cert->Equals(GetTestCert().get()));
 
   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,
+      ResourceType resource_type,
+      bool belongs_to_main_frame,
       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);
+    SetUpResourceLoader(std::move(request), resource_type,
+                        belongs_to_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::EFFECTIVE_CONNECTION_TYPE_SLOW_2G,
+  VerifyEffectiveConnectionType(RESOURCE_TYPE_MAIN_FRAME, 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::EFFECTIVE_CONNECTION_TYPE_3G,
+  VerifyEffectiveConnectionType(RESOURCE_TYPE_MAIN_FRAME, true,
+                                net::EFFECTIVE_CONNECTION_TYPE_3G,
                                 net::EFFECTIVE_CONNECTION_TYPE_3G);
 }
 
+// Tests that the effective connection type is not set on requests that belong
+// to main frame.
+TEST_F(EffectiveConnectionTypeResourceLoaderTest, BelongsToMainFrame) {
+  VerifyEffectiveConnectionType(RESOURCE_TYPE_OBJECT, true,
+                                net::EFFECTIVE_CONNECTION_TYPE_3G,
+                                net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
+}
+
 // Tests that the effective connection type is not set on non-main frame
 // requests.
-TEST_F(EffectiveConnectionTypeResourceLoaderTest, NotAMainFrame) {
-  VerifyEffectiveConnectionType(false, net::EFFECTIVE_CONNECTION_TYPE_3G,
+TEST_F(EffectiveConnectionTypeResourceLoaderTest, DoesNotBelongToMainFrame) {
+  VerifyEffectiveConnectionType(RESOURCE_TYPE_OBJECT, false,
+                                net::EFFECTIVE_CONNECTION_TYPE_3G,
                                 net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
 }
 
 }  // namespace content