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>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "net/base/auth.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_data_directory.h"
 #include "net/cookies/cookie_store_test_helpers.h"
+#include "net/http/http_server_properties_impl.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/http_transaction_test_util.h"
 #include "net/socket/socket_test_util.h"
 #include "net/test/cert_test_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 24 matching lines @@
 
 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() {
+  bool TransactionAcceptsSpecificEncoding(const std::string encoding) {
     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"))
+      if (base::EqualsCaseInsensitiveASCII(token, encoding))
         return true;
     }
     return false;
   }
 
+  bool TransactionAcceptsSdchEncoding() {
+    return TransactionAcceptsSpecificEncoding("sdch");
+  }
+
+  bool TransactionAcceptsBrotliEncoding() {
+    return TransactionAcceptsSpecificEncoding("br");
+  }
+
   void EnableSdch() {
     context_.SetSdchManager(scoped_ptr<SdchManager>(new SdchManager).Pass());
   }
 
+  void EnableBrotli() {
+    HttpNetworkSession::Params params;
+    params.enable_brotli = true;
+    params.http_server_properties = http_server_properties_.GetWeakPtr();
+    network_session_.reset(new HttpNetworkSession(params));
+    network_layer_.set_network_session(network_session_.get());

[xunjieli, 2015/12/02 18:26:31]

These two tests should really follow other URLRequestHttpJobWithMockSocketsTest
examples. 
You can then set the HttpNetworkSession::Params on the TestURLRequestContext. I
don't think we want to set a HttpNetworkSession on the MockNetworkLayer.

[eustas, 2015/12/03 12:32:07]

Nice idea. Done!

+  }
+
+  HttpServerPropertiesImpl http_server_properties_;
+  scoped_ptr<HttpNetworkSession> network_session_;
   MockNetworkLayer network_layer_;
   TestURLRequestContext context_;
   TestDelegate delegate_;
   scoped_ptr<URLRequest> req_;
 };
 
 class URLRequestHttpJobWithMockSocketsTest : public ::testing::Test {
  protected:
   URLRequestHttpJobWithMockSocketsTest()
       : context_(new TestURLRequestContext(true)) {
@@ skipping 517 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());
 }
 
+TEST_F(URLRequestHttpJobTest, NoBrotliAdvertisementOverHttp) {
+  EnableBrotli();
+  req_->set_method("GET");  // Redundant with default.
+  scoped_refptr<TestURLRequestHttpJob> job(
+      new TestURLRequestHttpJob(req_.get()));
+  job->Start();
+  EXPECT_FALSE(TransactionAcceptsBrotliEncoding());
+}
+
+TEST_F(URLRequestHttpJobTest, BrotliAdvertisement) {
+  EnableBrotli();
+  req_ = context_.CreateRequest(GURL("https://www.example.com"),
+                                DEFAULT_PRIORITY, &delegate_);
+  req_->set_method("GET");  // Redundant with default.
+  scoped_refptr<TestURLRequestHttpJob> job(
+      new TestURLRequestHttpJob(req_.get()));
+  job->Start();
+  EXPECT_TRUE(TransactionAcceptsBrotliEncoding());
+}
+
 // 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