Add brotli content-encoding filter.

net/url_request/url_request_http_job_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 "net/url_request/url_request_http_job.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 
@@ skipping 34 matching lines @@
 
   using URLRequestHttpJob::SetPriority;
   using URLRequestHttpJob::Start;
   using URLRequestHttpJob::Kill;
   using URLRequestHttpJob::priority;
 
  protected:
   ~TestURLRequestHttpJob() override {}
 };
 
+bool AcceptsEncoding(const HttpRequestHeaders& headers,
+                     const std::string encoding) {
+  std::string encoding_headers;
+  bool get_success = headers.GetHeader("Accept-Encoding", &encoding_headers);
+  EXPECT_TRUE(get_success);
+  if (!get_success)
+    return false;
+
+  // This check isn't wrapped with EXPECT* macros because different
+  // results from this function may be expected in different tests.
+  for (const std::string& token :
+       base::SplitString(encoding_headers, ", ", base::KEEP_WHITESPACE,
+                         base::SPLIT_WANT_NONEMPTY)) {
+    if (base::EqualsCaseInsensitiveASCII(token, encoding))
+      return true;
+  }
+  return false;
+}
+
 class URLRequestHttpJobTest : public ::testing::Test {
  protected:
   URLRequestHttpJobTest()
       : req_(context_.CreateRequest(GURL("http://www.example.com"),
                                     DEFAULT_PRIORITY,
                                     &delegate_)) {
     context_.set_http_transaction_factory(&network_layer_);
   }
 
   bool TransactionAcceptsSdchEncoding() {
     base::WeakPtr<MockNetworkTransaction> transaction(
         network_layer_.last_transaction());
     EXPECT_TRUE(transaction);
     if (!transaction) return false;
 
     const HttpRequestInfo* request_info = transaction->request();
     EXPECT_TRUE(request_info);
     if (!request_info) return false;
 
-    std::string encoding_headers;
-    bool get_success = request_info->extra_headers.GetHeader(
-        "Accept-Encoding", &encoding_headers);
-    EXPECT_TRUE(get_success);
-    if (!get_success) return false;
-
-    // This check isn't wrapped with EXPECT* macros because different
-    // results from this function may be expected in different tests.
-    for (const std::string& token :
-         base::SplitString(encoding_headers, ", ", base::KEEP_WHITESPACE,
-                           base::SPLIT_WANT_NONEMPTY)) {
-      if (base::EqualsCaseInsensitiveASCII(token, "sdch"))
-        return true;
-    }
-    return false;
+    return AcceptsEncoding(request_info->extra_headers, "sdch");
   }
 
   void EnableSdch() {
     context_.SetSdchManager(scoped_ptr<SdchManager>(new SdchManager).Pass());
   }
 
   MockNetworkLayer network_layer_;
   TestURLRequestContext context_;
   TestDelegate delegate_;
   scoped_ptr<URLRequest> req_;
@@ skipping 523 matching lines @@
 // Confirm we don't advertise SDCH encoding in the case of a POST.
 TEST_F(URLRequestHttpJobTest, SdchAdvertisementPost) {
   EnableSdch();
   req_->set_method("POST");
   scoped_refptr<TestURLRequestHttpJob> job(
       new TestURLRequestHttpJob(req_.get()));
   job->Start();
   EXPECT_FALSE(TransactionAcceptsSdchEncoding());
 }
 
+class URLRequestHttpJobWithBrotliSupportTest : public ::testing::Test {
+ protected:
+  URLRequestHttpJobWithBrotliSupportTest()
+      : context_(new TestURLRequestContext(true)) {
+    scoped_ptr<HttpNetworkSession::Params> params(
+        new HttpNetworkSession::Params);
+    params->enable_brotli = true;
+    context_->set_http_network_session_params(params.Pass());
+    context_->set_network_delegate(&network_delegate_);
+    context_->Init();
+  }
+
+  bool AcceptsBrotliEncoding() {
+    return AcceptsEncoding(network_delegate_.last_headers(), "br");

[xunjieli, 2015/12/04 15:21:19]

Let's not add "last_headers" to TestNetworkDelegate. The test class has 
too many internal states, and we shouldn't add one unless it's absolutely
necessary.

I'd suggest an alternative using mock sockets data.
In "URLRequestHttpJobWithMockSocketsTest.TestContentLengthSuccessfulRequest",
notice that they are using MockWrite and MockRead. We could do something
similar. In your "BrotliAdvertisement", we just need to do a mock write with
"Accept-Encoding: gzip, deflate, br". The test will then magically make sure
that the headers we are writing matches the mock writes.

[eustas, 2015/12/04 16:14:31]

Great idea! Thank you. Done.

+  }
+
+  void RunRequest(GURL url) {

[xunjieli, 2015/12/04 15:21:19]

nit: const GURL&

[eustas, 2015/12/04 16:14:31]

Done.

+    scoped_ptr<URLRequest> req(
+        context_->CreateRequest(url, DEFAULT_PRIORITY, &delegate_));
+    scoped_refptr<TestURLRequestHttpJob> job(
+        new TestURLRequestHttpJob(req.get()));
+    TestCompletionCallback dummy;
+    network_delegate_.NotifyBeforeURLRequest(req.get(), dummy.callback(), &url);
+    job->Start();
+    base::RunLoop().RunUntilIdle();
+  }
+
+  scoped_ptr<TestURLRequestContext> context_;

[xunjieli, 2015/12/04 15:21:19]

nit: add "private" before these variables.

[eustas, 2015/12/04 16:14:32]

Done.

+  TestNetworkDelegate network_delegate_;
+  TestDelegate delegate_;
+};
+
+TEST_F(URLRequestHttpJobWithBrotliSupportTest, NoBrotliAdvertisementOverHttp) {
+  RunRequest(GURL("http://www.example.com"));
+  EXPECT_FALSE(AcceptsBrotliEncoding());
+}
+
+TEST_F(URLRequestHttpJobWithBrotliSupportTest, BrotliAdvertisement) {
+  RunRequest(GURL("https://www.example.com"));
+  EXPECT_TRUE(AcceptsBrotliEncoding());
+}
+
 // This base class just serves to set up some things before the TestURLRequest
 // constructor is called.
 class URLRequestHttpJobWebSocketTestBase : public ::testing::Test {
  protected:
   URLRequestHttpJobWebSocketTestBase() : socket_data_(nullptr, 0, nullptr, 0),
                                          context_(true) {
     // A Network Delegate is required for the WebSocketHandshakeStreamBase
     // object to be passed on to the HttpNetworkTransaction.
     context_.set_network_delegate(&network_delegate_);
 
@@ skipping 147 matching lines @@
   req_->SetLoadFlags(LOAD_DISABLE_CACHE);
   job->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(URLRequestStatus::IO_PENDING, req_->status().status());
   EXPECT_TRUE(fake_handshake_stream->initialize_stream_was_called());
 }
 
 }  // namespace
 
 }  // namespace net