Enable setting deferral state on ResourceDispatcher at request start

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>
@@ skipping 41 matching lines @@
 // but rather correct cleanup when deleted while parsing.  Important details of
 // this list are that it contains more than one entry that are not "." or "..".
 const char kFtpDirListing[] =
     "drwxr-xr-x    3 ftp      ftp          4096 May 15 18:11 goat\n"
     "drwxr-xr-x    3 ftp      ftp          4096 May 15 18:11 hat";
 
 class TestResourceDispatcher : public ResourceDispatcher {
  public:
   TestResourceDispatcher() :
       ResourceDispatcher(nullptr, nullptr),
-      canceled_(false) {
+      canceled_(false),
+      defers_loading_(false) {
   }
 
   ~TestResourceDispatcher() override {}
 
   // TestDispatcher implementation:
 
   int StartAsync(const RequestInfo& request_info,
                  ResourceRequestBody* 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_; }
+
  private:
   std::unique_ptr<RequestPeer> peer_;
   bool canceled_;
+  bool defers_loading_;
   GURL url_;
   GURL stream_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcher);
 };
 
 class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
  public:
   TestWebURLLoaderClient(ResourceDispatcher* dispatcher,
                          scoped_refptr<scheduler::TaskQueue> task_runner)
@@ skipping 389 matching lines @@
   client()->loader()->setDefersLoading(false);
   client()->loader()->setDefersLoading(false);
   message_loop()->RunUntilIdle();
   EXPECT_TRUE(client()->did_finish());
 
   EXPECT_EQ("blah!", client()->received_data());
   EXPECT_EQ(net::OK, client()->error().reason);
   EXPECT_EQ("", client()->error().domain.utf8());
 }
 
+TEST_F(WebURLLoaderImplTest, DefersLoadingBeforeStart) {
+  client()->loader()->setDefersLoading(true);
+  EXPECT_FALSE(dispatcher()->defers_loading());
+  DoStartAsyncRequest();
+  EXPECT_TRUE(dispatcher()->defers_loading());
+}
+
 // FTP integration tests.  These are focused more on safe deletion than correct
 // parsing of FTP responses.
 
 TEST_F(WebURLLoaderImplTest, Ftp) {
   DoStartAsyncRequest();
   DoReceiveResponseFtp();
   DoReceiveDataFtp();
   DoCompleteRequest();
   EXPECT_FALSE(dispatcher()->canceled());
 }
@@ skipping 109 matching lines @@
     info.socket_address = net::HostPortPair(test.ip, 443);
     blink::WebURLResponse response;
     response.initialize();
     WebURLLoaderImpl::PopulateURLResponse(url, info, &response, true);
     EXPECT_EQ(test.expected, response.remoteIPAddress().utf8());
   };
 }
 
 }  // namespace
 }  // namespace content