Render process changes for ResourceTiming sizes.

content/child/web_url_loader_impl_unittest.cc

 // Copyright 2014 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/child/web_url_loader_impl.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
 #include "components/scheduler/child/scheduler_tqm_delegate_impl.h"
 #include "components/scheduler/child/web_task_runner_impl.h"
 #include "components/scheduler/child/worker_scheduler.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/request_info.h"
 #include "content/child/resource_dispatcher.h"
+#include "content/child/sync_load_response.h"
 #include "content/public/child/fixed_received_data.h"
 #include "content/public/child/request_peer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/resource_response_info.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/redirect_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 23 matching lines @@
   TestResourceDispatcher() :
       ResourceDispatcher(nullptr, nullptr),
       canceled_(false),
       defers_loading_(false) {
   }
 
   ~TestResourceDispatcher() override {}
 
   // TestDispatcher implementation:
 
+  void StartSync(const RequestInfo& request_info,
+                 ResourceRequestBodyImpl* request_body,
+                 SyncLoadResponse* response) override {
+    *response = sync_load_response_;
+  }
+
   int StartAsync(const RequestInfo& request_info,
                  ResourceRequestBodyImpl* request_body,
                  std::unique_ptr<RequestPeer> peer) override {
     EXPECT_FALSE(peer_);
     peer_ = std::move(peer);
     url_ = request_info.url;
     stream_url_ = request_info.resource_body_stream_url;
     return 1;
   }
 
   void Cancel(int request_id) override {
     EXPECT_FALSE(canceled_);
     canceled_ = true;
   }
 
   RequestPeer* peer() { return peer_.get(); }
 
   bool canceled() { return canceled_; }
 
   const GURL& url() { return url_; }
   const GURL& stream_url() { return stream_url_; }
 
   void SetDefersLoading(int request_id, bool value) override {
     defers_loading_ = value;
   }
   bool defers_loading() const { return defers_loading_; }
 
+  void set_sync_load_response(const SyncLoadResponse& sync_load_response) {
+    sync_load_response_ = sync_load_response;
+  }
+
  private:
   std::unique_ptr<RequestPeer> peer_;
   bool canceled_;
   bool defers_loading_;
   GURL url_;
   GURL stream_url_;
+  SyncLoadResponse sync_load_response_;
 
   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcher);
 };
 
 class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
  public:
   TestWebURLLoaderClient(ResourceDispatcher* dispatcher,
                          scoped_refptr<scheduler::TaskQueue> task_runner)
       : loader_(new WebURLLoaderImpl(
             dispatcher,
             base::WrapUnique(new scheduler::WebTaskRunnerImpl(task_runner)))),
         delete_on_receive_redirect_(false),
         delete_on_receive_response_(false),
         delete_on_receive_data_(false),
         delete_on_finish_(false),
         delete_on_fail_(false),
         did_receive_redirect_(false),
         did_receive_response_(false),
         check_redirect_request_priority_(false),
         did_finish_(false) {}
 
   ~TestWebURLLoaderClient() override {}
 
   // blink::WebURLLoaderClient implementation:
-  void willFollowRedirect(
-      blink::WebURLLoader* loader,
-      blink::WebURLRequest& newRequest,
-      const blink::WebURLResponse& redirectResponse) override {
+  void willFollowRedirect(blink::WebURLLoader* loader,
+                          blink::WebURLRequest& newRequest,
+                          const blink::WebURLResponse& redirectResponse,
+                          int64_t encodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
 
     if (check_redirect_request_priority_)
       EXPECT_EQ(redirect_request_priority, newRequest.getPriority());
 
     // No test currently simulates mutiple redirects.
     EXPECT_FALSE(did_receive_redirect_);
     did_receive_redirect_ = true;
 
@@ skipping 24 matching lines @@
   void didDownloadData(blink::WebURLLoader* loader,
                        int dataLength,
                        int encodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
   }
 
   void didReceiveData(blink::WebURLLoader* loader,
                       const char* data,
                       int dataLength,
-                      int encodedDataLength) override {
+                      int encodedDataLength,
+                      int encodedBodyLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     // The response should have started, but must not have finished, or failed.
     EXPECT_TRUE(did_receive_response_);
     EXPECT_FALSE(did_finish_);
     EXPECT_EQ(net::OK, error_.reason);
     EXPECT_EQ("", error_.domain.utf8());
 
     received_data_.append(data, dataLength);
 
@@ skipping 118 matching lines @@
 
   void DoReceiveResponse() {
     EXPECT_FALSE(client()->did_receive_response());
     peer()->OnReceivedResponse(content::ResourceResponseInfo());
     EXPECT_TRUE(client()->did_receive_response());
   }
 
   // Assumes it is called only once for a request.
   void DoReceiveData() {
     EXPECT_EQ("", client()->received_data());
-    peer()->OnReceivedData(base::WrapUnique(new FixedReceivedData(
-        kTestData, strlen(kTestData), strlen(kTestData))));
+    auto size = strlen(kTestData);
+    peer()->OnReceivedData(
+        base::WrapUnique(new FixedReceivedData(kTestData, size, size, size)));
     EXPECT_EQ(kTestData, client()->received_data());
   }
 
   void DoCompleteRequest() {
     EXPECT_FALSE(client()->did_finish());
     peer()->OnCompletedRequest(net::OK, false, false, "", base::TimeTicks(),
                                strlen(kTestData));
     EXPECT_TRUE(client()->did_finish());
     // There should be no error.
     EXPECT_EQ(net::OK, client()->error().reason);
@@ skipping 11 matching lines @@
 
   void DoReceiveResponseFtp() {
     EXPECT_FALSE(client()->did_receive_response());
     content::ResourceResponseInfo response_info;
     response_info.mime_type = kFtpDirMimeType;
     peer()->OnReceivedResponse(response_info);
     EXPECT_TRUE(client()->did_receive_response());
   }
 
   void DoReceiveDataFtp() {
-    peer()->OnReceivedData(base::WrapUnique(new FixedReceivedData(
-        kFtpDirListing, strlen(kFtpDirListing), strlen(kFtpDirListing))));
+    auto size = strlen(kFtpDirListing);
+    peer()->OnReceivedData(base::WrapUnique(
+        new FixedReceivedData(kFtpDirListing, size, size, size)));
     // The FTP delegate should modify the data the client sees.
     EXPECT_NE(kFtpDirListing, client()->received_data());
   }
 
   TestWebURLLoaderClient* client() { return client_.get(); }
   TestResourceDispatcher* dispatcher() { return &dispatcher_; }
   RequestPeer* peer() { return dispatcher()->peer(); }
   base::MessageLoop* message_loop() { return &message_loop_; }
 
  private:
@@ skipping 299 matching lines @@
   for (const auto& test : cases) {
     SCOPED_TRACE(test.ip);
     content::ResourceResponseInfo info;
     info.socket_address = net::HostPortPair(test.ip, 443);
     blink::WebURLResponse response;
     WebURLLoaderImpl::PopulateURLResponse(url, info, &response, true);
     EXPECT_EQ(test.expected, response.remoteIPAddress().utf8());
   };
 }
 
+// Verifies that the lengths used by the PerformanceResourceTiming API are
+// correctly assigned for sync XHR.
+TEST_F(WebURLLoaderImplTest, SyncLengths) {
+  static const char kBodyData[] =  "Today is Thursday";
+  const int kEncodedBodyLength = 30;
+  const GURL url(kTestURL);
+  blink::WebURLRequest request(url);
+
+  // Prepare a mock response
+  SyncLoadResponse sync_load_response;
+  sync_load_response.error_code = net::OK;
+  sync_load_response.url = url;
+  sync_load_response.data = kBodyData;
+  ASSERT_EQ(17u, sync_load_response.data.size());
+  sync_load_response.encoded_body_length = kEncodedBodyLength;
+  dispatcher()->set_sync_load_response(sync_load_response);
+
+  blink::WebURLResponse response;
+  blink::WebURLError error;
+  blink::WebData data;
+  client()->loader()->loadSynchronously(request, response, error, data);
+
+  EXPECT_EQ(kEncodedBodyLength, response.encodedBodyLength());
+  int expected_decoded_body_length = strlen(kBodyData);
+  EXPECT_EQ(expected_decoded_body_length, response.decodedBodyLength());
+}
+
 }  // namespace
 }  // namespace content