Don't pass SDCH GetDictionary event for cached responses

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/sdch_observer.h"
 #include "net/base/test_data_directory.h"
 #include "net/cookies/cookie_store_test_helpers.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"
@@ skipping 571 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_ptr<TestURLRequestHttpJob> job(new TestURLRequestHttpJob(req_.get()));
   job->Start();
   EXPECT_FALSE(TransactionAcceptsSdchEncoding());
 }
 
+class MockSdchObserver : public SdchObserver {
+ public:
+  MockSdchObserver() {}
+  MOCK_METHOD2(OnDictionaryAdded,
+               void(const GURL& request_url, const std::string& server_hash));
+  MOCK_METHOD1(OnDictionaryRemoved, void(const std::string& server_hash));
+  MOCK_METHOD1(OnDictionaryUsed, void(const std::string& server_hash));
+  MOCK_METHOD2(OnGetDictionary,
+               void(const GURL& request_url, const GURL& dictionary_url));
+  MOCK_METHOD0(OnClearDictionaries, void());
+};
+
+class URLRequestHttpJobWithSdchSupportTest : public ::testing::Test {
+ protected:
+  URLRequestHttpJobWithSdchSupportTest() : context_(true) {
+    scoped_ptr<HttpNetworkSession::Params> params(
+        new HttpNetworkSession::Params);
+    context_.set_http_network_session_params(std::move(params));
+    context_.set_client_socket_factory(&socket_factory_);
+    context_.Init();
+  }
+
+  MockClientSocketFactory socket_factory_;
+  TestURLRequestContext context_;
+};
+
+TEST_F(URLRequestHttpJobWithSdchSupportTest, GetDictionary) {
+  MockWrite writes[] = {
+      MockWrite("GET / HTTP/1.1\r\n"
+                "Host: example.com\r\n"
+                "Connection: keep-alive\r\n"
+                "User-Agent:\r\n"
+                "Accept-Encoding: gzip, deflate, sdch\r\n"
+                "Accept-Language: en-us,fr\r\n\r\n")};
+
+  MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
+                               "Get-Dictionary: /sdch.dict\r\n"
+                               "Cache-Control: max-age=120\r\n"
+                               "Content-Length: 12\r\n\r\n"),
+                      MockRead("Test Content")};
+  StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
+                                       arraysize(writes));
+  socket_factory_.AddSocketDataProvider(&socket_data);
+
+  MockSdchObserver sdch_observer;
+  SdchManager sdch_manager;
+  sdch_manager.AddObserver(&sdch_observer);
+  context_.set_sdch_manager(&sdch_manager);
+
+  // First response will be "from network" and we should have OnGetDictionary
+  // invoked.
+  GURL url("http://example.com");
+  EXPECT_CALL(sdch_observer,
+              OnGetDictionary(url, GURL("http://example.com/sdch.dict")));
+  TestDelegate delegate;
+  scoped_ptr<URLRequest> request =
+      context_.CreateRequest(url, DEFAULT_PRIORITY, &delegate);
+  request->Start();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(request->status().is_success());
+
+  // Second response should be from cache without notification of SdchObserver
+  TestDelegate delegate2;
+  scoped_ptr<URLRequest> request2 =
+      context_.CreateRequest(url, DEFAULT_PRIORITY, &delegate2);
+  request2->Start();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(request->status().is_success());
+
+  // Cleanup manager.
+  sdch_manager.RemoveObserver(&sdch_observer);
+}
+
 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(std::move(params));
     context_->set_client_socket_factory(&socket_factory_);
     context_->Init();
@@ skipping 221 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