Move data reduction proxy logic out of chrome and android webview network delegate

net/base/layered_network_delegate_unittest.cc

Index: net/base/layered_network_delegate_unittest.cc
diff --git a/net/base/layered_network_delegate_unittest.cc b/net/base/layered_network_delegate_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a64799326010fdb89049c0b09b908dd669d9dbc7
--- /dev/null
+++ b/net/base/layered_network_delegate_unittest.cc
@@ -0,0 +1,400 @@
+// 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 "net/base/layered_network_delegate.h"
+
+#include "base/bind.h"
+#include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/auth.h"
+#include "net/base/net_errors.h"
+#include "net/base/network_delegate_impl.h"
+#include "net/base/request_priority.h"
+#include "net/base/test_completion_callback.h"
+#include "net/http/http_response_headers.h"
+#include "net/proxy/proxy_config_service.h"
+#include "net/proxy/proxy_info.h"
+#include "net/proxy/proxy_service.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace net {
+
+typedef std::map<const char*, int> CountersMap;

[mmenke, 2014/12/03 18:50:38]

include map.

[megjablon, 2014/12/04 01:23:46]

Done.

+
+void VerifyCounters(CountersMap counters, int64 count) {

[mmenke, 2014/12/03 18:50:38]

int64 not needed

[mmenke, 2014/12/03 18:50:38]

Actually, can you just get rid of this method, and check that the corresponding
counter is 1 in each of the callbacks?  That'll also print a more useful error
on failure.

[megjablon, 2014/12/04 01:23:46]

Done.

+  for (CountersMap::iterator iter = counters.begin();
+      iter != counters.end(); ++iter) {
+    EXPECT_EQ(count, iter->second);
+  }
+}
+
+class TestProxyConfigService : public ProxyConfigService {

[mmenke, 2014/12/03 18:50:38]

Not needed.  Can just use ProxyService::CreateDirect() and stick it in a
scoped_ptr to create a proxy service for the test.

[megjablon, 2014/12/04 01:23:46]

Done.

+ public:
+  TestProxyConfigService() {
+  }
+
+  void AddObserver(ProxyConfigService::Observer* observer) override {
+  }
+
+  void RemoveObserver(ProxyConfigService::Observer* observer) override {
+  }
+
+  ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) override {
+    return ProxyConfigService::CONFIG_VALID;
+  }
+};
+
+class TestNetworkDelegateImpl : public NetworkDelegateImpl {
+ public:
+  TestNetworkDelegateImpl() {
+  }
+
+  ~TestNetworkDelegateImpl() override {
+  }
+
+  void VerifyCalled(int64 count) {
+    VerifyCounters(counters_, count);
+  }
+
+ private:
+  int OnBeforeURLRequest(URLRequest* request,
+                         const CompletionCallback& callback,
+                         GURL* new_url) override {
+    ++counters_["on_before_url_request_count"];

[mmenke, 2014/12/03 18:50:38]

Hrm...  It's a pain, but if we want to be complete, perhaps we should have check
that the TestLayeredNetworkDelegate's corresponding counter has already been
incremented on all of these.  Via a method, of
course...IncrementAndCompareCounter("...");

[megjablon, 2014/12/04 01:23:46]

Done.

+    return OK;
+  }
+
+  void OnResolveProxy(const GURL& url,
+                      int load_flags,
+                      const ProxyService& proxy_service,
+                      ProxyInfo* result) override {
+    ++counters_["on_resolve_proxy_count"];
+  }
+
+  void OnProxyFallback(const ProxyServer& bad_proxy, int net_error) override {
+    ++counters_["on_proxy_fallback_count"];
+  }
+
+  int OnBeforeSendHeaders(URLRequest* request,
+                          const CompletionCallback& callback,
+                          HttpRequestHeaders* headers) override {
+    ++counters_["on_before_send_headers_count"];
+    return OK;
+  }
+
+  void OnBeforeSendProxyHeaders(URLRequest* request,
+                                const ProxyInfo& proxy_info,
+                                HttpRequestHeaders* headers) override {
+    ++counters_["on_before_send_proxy_headers_count"];
+  }
+
+  void OnSendHeaders(URLRequest* request,
+                     const HttpRequestHeaders& headers) override {
+    ++counters_["on_send_headers_count"];
+  }
+
+  int OnHeadersReceived(
+      URLRequest* request,
+      const CompletionCallback& callback,
+      const HttpResponseHeaders* original_response_headers,
+      scoped_refptr<HttpResponseHeaders>* override_response_headers,
+      GURL* allowed_unsafe_redirect_url) override {
+    ++counters_["on_headers_received_count"];
+    return OK;
+  }
+
+  void OnBeforeRedirect(URLRequest* request,
+                        const GURL& new_location) override {
+    ++counters_["on_before_redirect_count"];
+  }
+
+  void OnResponseStarted(URLRequest* request) override {
+    ++counters_["on_response_started_count"];
+  }
+
+  void OnRawBytesRead(const URLRequest& request, int bytes_read) override {
+    ++counters_["on_raw_bytes_read_count"];
+  }
+
+  void OnCompleted(URLRequest* request, bool started) override {
+    ++counters_["on_completed_count"];
+  }
+
+  void OnURLRequestDestroyed(URLRequest* request) override {
+    ++counters_["on_url_request_destroyed_count"];
+  }
+
+  void OnPACScriptError(int line_number,
+                        const base::string16& error) override {
+    ++counters_["on_pac_script_error_count"];
+  }
+
+  AuthRequiredResponse OnAuthRequired(URLRequest* request,
+                                      const AuthChallengeInfo& auth_info,
+                                      const AuthCallback& callback,
+                                      AuthCredentials* credentials) override {
+    ++counters_["on_auth_required_count"];
+    return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
+  }
+
+  bool OnCanGetCookies(const URLRequest& request,
+                       const CookieList& cookie_list) override {
+    ++counters_["on_can_get_cookies_count"];
+    return false;
+  }
+
+  bool OnCanSetCookie(const URLRequest& request,
+                      const std::string& cookie_line,
+                      CookieOptions* options) override {
+    ++counters_["on_can_set_cookie_count"];
+    return false;
+  }
+
+  CountersMap counters_;
+};
+
+class TestNetworkDelegateImplMock : public TestNetworkDelegateImpl {
+ public:
+  TestNetworkDelegateImplMock() {
+  }
+
+  ~TestNetworkDelegateImplMock() override {
+  }
+
+  MOCK_CONST_METHOD2(OnCanAccessFile,
+                     bool(const URLRequest& request,
+                          const base::FilePath& path));
+
+  MOCK_CONST_METHOD1(OnCanThrottleRequest,
+                     bool(const URLRequest& request));
+
+  MOCK_CONST_METHOD2(OnCanEnablePrivacyMode,
+                     bool(const GURL& url,
+                          const GURL& first_party_for_cookies));
+
+  MOCK_CONST_METHOD3(
+      OnCancelURLRequestWithPolicyViolatingReferrerHeader,
+      bool(const URLRequest& request,
+           const GURL& target_url,
+           const GURL& referrer_url));
+};
+
+class TestLayeredNetworkDelegate : public LayeredNetworkDelegate {
+ public:
+  TestLayeredNetworkDelegate(scoped_ptr<NetworkDelegate> network_delegate)
+      : LayeredNetworkDelegate(network_delegate.Pass()),
+        context_(true) {
+    context_.Init();
+  }
+
+  ~TestLayeredNetworkDelegate() override {
+  }
+
+  void MakeCalls() {
+    scoped_refptr<AuthChallengeInfo> auth_challenge( new AuthChallengeInfo());
+    scoped_ptr<URLRequest> request = context_.CreateRequest(
+        GURL(), IDLE, &delegate_, NULL);
+    scoped_ptr<HttpRequestHeaders> request_headers(new HttpRequestHeaders());
+    scoped_refptr<HttpResponseHeaders> response_headers(
+        new HttpResponseHeaders(""));
+    TestCompletionCallback completion_callback;
+    OnBeforeURLRequest(request.get(), completion_callback.callback(), NULL);
+    OnResolveProxy(GURL(), 0,
+                   ProxyService(new TestProxyConfigService(), NULL, NULL),
+                   new ProxyInfo());
+    OnProxyFallback(ProxyServer(), 0);
+    OnBeforeSendHeaders(
+        NULL, completion_callback.callback(), request_headers.get());
+    OnBeforeSendProxyHeaders(NULL, ProxyInfo(), request_headers.get());
+    OnSendHeaders(NULL, *request_headers.get());
+    OnHeadersReceived(
+        NULL, completion_callback.callback(),
+        response_headers.get(), NULL, NULL);
+    OnResponseStarted(request.get());
+    OnRawBytesRead(*request.get(), 0);

[mmenke, 2014/12/03 18:50:38]

Think *request can be used instead of *request.get()

[megjablon, 2014/12/04 01:23:46]

Done.

+    OnCompleted(request.get(), false);
+    OnURLRequestDestroyed(request.get());
+    OnPACScriptError(0, base::string16());
+    OnAuthRequired(request.get(), *auth_challenge.get(), AuthCallback(), NULL);
+    OnCanGetCookies(*request.get(), CookieList());
+    OnCanSetCookie(*request.get(), std::string(), NULL);
+    OnCanAccessFile(*request.get(), base::FilePath());
+    OnCanThrottleRequest(*request.get());
+    OnCanEnablePrivacyMode(GURL(), GURL());
+    OnCancelURLRequestWithPolicyViolatingReferrerHeader(
+        *request.get(), GURL(), GURL());

[mmenke, 2014/12/03 18:50:38]

Maybe use EXPECT_EQ for those that return values?

[megjablon, 2014/12/04 01:23:46]

Done.

+  }
+
+  void VerifyCalled(int64 count) {
+    VerifyCounters(counters_, count);
+  }
+
+ private:
+  void OnBeforeURLRequestInternal(URLRequest* request,
+                                  const CompletionCallback& callback,
+                                  GURL* new_url) override {
+    ++counters_["on_before_url_request_count"];
+  }
+
+  void OnResolveProxyInternal(const GURL& url,
+                              int load_flags,
+                              const ProxyService& proxy_service,
+                              ProxyInfo* result) override {
+    ++counters_["on_resolve_proxy_count"];
+  }
+
+  void OnProxyFallbackInternal(const ProxyServer& bad_proxy,
+                               int net_error) override {
+    ++counters_["on_proxy_fallback_count"];
+  }
+
+  void OnBeforeSendHeadersInternal(URLRequest* request,
+                                   const CompletionCallback& callback,
+                                   HttpRequestHeaders* headers) override {
+    ++counters_["on_before_send_headers_count"];
+  }
+
+  void OnBeforeSendProxyHeadersInternal(URLRequest* request,
+                                        const ProxyInfo& proxy_info,
+                                        HttpRequestHeaders* headers) override {
+    ++counters_["on_before_send_proxy_headers_count"];
+  }
+
+  void OnSendHeadersInternal(URLRequest* request,
+                             const HttpRequestHeaders& headers) override {
+
+    ++counters_["on_send_headers_count"];
+  }
+
+  void OnHeadersReceivedInternal(
+      URLRequest* request,
+      const CompletionCallback& callback,
+      const HttpResponseHeaders* original_response_headers,
+      scoped_refptr<HttpResponseHeaders>* override_response_headers,
+      GURL* allowed_unsafe_redirect_url) override {
+    ++counters_["on_headers_received_count"];
+  }
+
+  void OnBeforeRedirectInternal(URLRequest* request,
+                                const GURL& new_location) override {
+    ++counters_["on_before_redirect_count"];
+  }
+
+  void OnResponseStartedInternal(URLRequest* request) override {
+    ++counters_["on_response_started_count"];
+  }
+
+  void OnRawBytesReadInternal(const URLRequest& request,
+                              int bytes_read) override {
+    ++counters_["on_raw_bytes_read_count"];
+  }
+
+  void OnCompletedInternal(URLRequest* request, bool started) override {
+    ++counters_["on_completed_count"];
+  }
+
+  void OnURLRequestDestroyedInternal(URLRequest* request) override {
+    ++counters_["on_url_request_destroyed_count"];
+  }
+
+  void OnPACScriptErrorInternal(int line_number,
+                                const base::string16& error) override {
+    ++counters_["on_pac_script_error_count"];
+  }
+
+  void OnAuthRequiredInternal(URLRequest* request,
+                              const AuthChallengeInfo& auth_info,
+                              const AuthCallback& callback,
+                              AuthCredentials* credentials) override {
+    ++counters_["on_auth_required_count"];
+  }
+
+  void OnCanGetCookiesInternal(const URLRequest& request,
+                               const CookieList& cookie_list) override {
+    ++counters_["on_can_get_cookies_count"];
+  }
+
+  void OnCanSetCookieInternal(const URLRequest& request,
+                              const std::string& cookie_line,
+                              CookieOptions* options) override {
+    ++counters_["on_can_set_cookie_count"];
+  }
+
+  TestURLRequestContext context_;
+  TestDelegate delegate_;
+  CountersMap counters_;

[mmenke, 2014/12/03 18:50:38]

DISALLOW_COPY_AND_ASSIGN

[megjablon, 2014/12/04 01:23:46]

Done.

+};
+
+class TestLayeredNetworkDelegateMock : public TestLayeredNetworkDelegate {
+ public:
+  TestLayeredNetworkDelegateMock(scoped_ptr<NetworkDelegate> network_delegate)
+      : TestLayeredNetworkDelegate(network_delegate.Pass()) {
+  }
+
+  ~TestLayeredNetworkDelegateMock() override {
+  }
+
+  MOCK_CONST_METHOD2(OnCanAccessFileInternal,

[mmenke, 2014/12/03 18:50:38]

Probably shouldn't be using gmock, so hacking on Chrome doesn't require
knowledge of it.

[megjablon, 2014/12/04 01:23:46]

Done.

+                     void(const URLRequest& request,
+                          const base::FilePath& path));
+
+  MOCK_CONST_METHOD1(OnCanThrottleRequestInternal,
+                     void(const URLRequest& request));
+
+  MOCK_CONST_METHOD2(OnCanEnablePrivacyModeInternal,
+                     void(const GURL& url,
+                          const GURL& first_party_for_cookies));
+
+  MOCK_CONST_METHOD3(
+      OnCancelURLRequestWithPolicyViolatingReferrerHeaderInternal,
+      void(const URLRequest& request,
+           const GURL& target_url,
+           const GURL& referrer_url));
+};
+
+class LayeredNetworkDelegateTest : public testing::Test {
+ public:
+  LayeredNetworkDelegateTest() {
+    scoped_ptr<TestNetworkDelegateImplMock> test_network_delegate(
+        new TestNetworkDelegateImplMock());
+    test_network_delegate_ = test_network_delegate.get();
+    layered_network_delegate_ = scoped_ptr<TestLayeredNetworkDelegateMock>(
+       new TestLayeredNetworkDelegateMock(test_network_delegate.Pass()));
+  }
+
+  TestNetworkDelegateImplMock* test_network_delegate_;
+  scoped_ptr<TestLayeredNetworkDelegateMock> layered_network_delegate_;
+};
+
+TEST_F(LayeredNetworkDelegateTest, VerifyLayeredNetworkDelegateInternal) {
+  EXPECT_CALL(*test_network_delegate_, OnCanAccessFile(testing::_, testing::_));
+  EXPECT_CALL(*test_network_delegate_, OnCanThrottleRequest(testing::_));
+  EXPECT_CALL(*test_network_delegate_,
+              OnCanEnablePrivacyMode(testing::_, testing::_));
+  EXPECT_CALL(*test_network_delegate_,
+              OnCancelURLRequestWithPolicyViolatingReferrerHeader(
+                  testing::_, testing::_, testing::_));
+
+  EXPECT_CALL(*layered_network_delegate_.get(),
+              OnCanAccessFileInternal(testing::_, testing::_));

[mmenke, 2014/12/03 18:50:38]

Why are these calls separated out?

[megjablon, 2014/12/04 01:23:46]

Done.

+  EXPECT_CALL(*layered_network_delegate_.get(),
+              OnCanThrottleRequestInternal(testing::_));
+  EXPECT_CALL(*layered_network_delegate_.get(),
+              OnCanEnablePrivacyModeInternal(testing::_, testing::_));
+  EXPECT_CALL(*layered_network_delegate_.get(),
+              OnCancelURLRequestWithPolicyViolatingReferrerHeaderInternal(
+                  testing::_, testing::_, testing::_));
+
+  layered_network_delegate_->MakeCalls();
+
+  test_network_delegate_->VerifyCalled(1);
+  layered_network_delegate_->VerifyCalled(1);

[mmenke, 2014/12/03 18:50:38]

Should compare the total number of calls to the two is the same.

[megjablon, 2014/12/04 01:23:46]

This is now checked in IncrementAndCompareCounter

+}
+
+}  // namespace net