CREDENTIAL: Rework the integration with Fetch (2/2)

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>
@@ skipping 53 matching lines @@
 
   // TestDispatcher implementation:
 
   int StartAsync(const RequestInfo& request_info,
                  ResourceRequestBody* request_body,
                  scoped_ptr<RequestPeer> peer) override {
     EXPECT_FALSE(peer_);
     peer_ = std::move(peer);
     url_ = request_info.url;
     stream_url_ = request_info.resource_body_stream_url;
+    empty_body_in_service_worker_ = request_info.empty_body_in_service_worker;
     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_; }
+  bool empty_body_in_service_worker() const {
+    return empty_body_in_service_worker_;
+  }
 
  private:
   scoped_ptr<RequestPeer> peer_;
   bool canceled_;
   GURL url_;
   GURL stream_url_;
+  bool empty_body_in_service_worker_;
 
   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcher);
 };
 
 class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
  public:
   TestWebURLLoaderClient(ResourceDispatcher* dispatcher,
                          scoped_refptr<scheduler::TaskQueue> task_runner)
       : loader_(new WebURLLoaderImpl(
             dispatcher,
@@ skipping 487 matching lines @@
   // The response info should have been overriden.
   ASSERT_FALSE(client()->response().isNull());
   EXPECT_EQ(kMimeType, client()->response().mimeType().latin1());
 
   DoReceiveData();
   DoCompleteRequest();
   EXPECT_FALSE(dispatcher()->canceled());
   EXPECT_EQ(kTestData, client()->received_data());
 }
 
+TEST_F(WebURLLoaderImplTest, EmptyBodyInServiceWorkerNoCredential) {
+  // Initialize the request and kick off the load
+  blink::WebURLRequest request;
+  request.initialize();
+  request.setURL(GURL(kTestURL));
+  request.setHTTPMethod("POST");
+  client()->loader()->loadAsynchronously(request, client());
+
+  // No credential body, so the body can be given to the service worker.
+  EXPECT_FALSE(dispatcher()->empty_body_in_service_worker());
+}
+
+TEST_F(WebURLLoaderImplTest, EmptyBodyInServiceWorkerWithCredential) {
+  // Initialize the request and kick off the load
+  blink::WebURLRequest request;
+  request.initialize();
+  request.setHTTPMethod("POST");
+  request.setURL(GURL(kTestURL));

[tyoshino (SeeGerritForStatus), 2016/04/12 16:30:25]

order these two lines the same as EmptyBodyInServiceWorkerNoCredential unless
needed

+
+  blink::WebHTTPBody body;
+  body.initialize();
+  request.setAttachedCredentialBody(body);
+  client()->loader()->loadAsynchronously(request, client());
+
+  // No credential body, so the body can be given to the service worker.
+  EXPECT_TRUE(dispatcher()->empty_body_in_service_worker());
+}
+
 TEST_F(WebURLLoaderImplTest, ResponseIPAddress) {
   GURL url("http://example.test/");
 
   struct TestCase {
     const char* ip;
     const char* expected;
   } cases[] = {
       {"127.0.0.1", "127.0.0.1"},
       {"123.123.123.123", "123.123.123.123"},
       {"::1", "[::1]"},
       {"2001:0db8:85a3:0000:0000:8a2e:0370:7334",
        "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]"},
       {"2001:db8:85a3:0:0:8a2e:370:7334", "[2001:db8:85a3:0:0:8a2e:370:7334]"},
       {"2001:db8:85a3::8a2e:370:7334", "[2001:db8:85a3::8a2e:370:7334]"},
       {"::ffff:192.0.2.128", "[::ffff:192.0.2.128]"}};
 
   for (const auto& test : cases) {
     SCOPED_TRACE(test.ip);
     content::ResourceResponseInfo info;
     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