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

net/base/wrapping_network_delegate_unittest.cc

Index: net/base/wrapping_network_delegate_unittest.cc
diff --git a/net/base/wrapping_network_delegate_unittest.cc b/net/base/wrapping_network_delegate_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cc97cd90849001eaef3efb646149db4aa3f3fd84
--- /dev/null
+++ b/net/base/wrapping_network_delegate_unittest.cc
@@ -0,0 +1,397 @@
+// 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/wrapping_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/proxy/proxy_config_service.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 {

[mmenke, 2014/11/26 15:23:53]

Should nest this in the net namespace, and remove all net::'s

[megjablon, 2014/12/01 19:26:56]

Done.

+
+typedef std::map<const char*, int64> CountersMap;

[mmenke, 2014/11/26 15:23:53]

Don't think you really need an int64 here

[megjablon, 2014/12/01 19:26:56]

Done.

+
+void VerifyCounters(CountersMap counters, int64 count) {
+  for (CountersMap::iterator iter = counters.begin();
+      iter != counters.end(); ++iter) {
+    EXPECT_EQ(count, iter->second);
+  }
+}
+
+class TestProxyConfigService : public net::ProxyConfigService {
+ public:
+  TestProxyConfigService() {
+  }
+
+  void AddObserver(net::ProxyConfigService::Observer* observer) override {
+  }
+
+  void RemoveObserver(net::ProxyConfigService::Observer* observer) override {
+  }
+
+  ConfigAvailability GetLatestProxyConfig(net::ProxyConfig* config) override {
+    return ProxyConfigService::CONFIG_VALID;
+  }
+};
+
+class TestNetworkDelegateImpl : public net::NetworkDelegateImpl {
+ public:
+  TestNetworkDelegateImpl() {
+  }
+
+  virtual ~TestNetworkDelegateImpl() {

[mmenke, 2014/11/26 15:23:53]

-virtual + override

[megjablon, 2014/12/01 19:26:56]

Done.

+  }
+
+  void VerifyCalled(int64 count) {
+    VerifyCounters(counters_, count);
+  }
+
+ private:
+  int OnBeforeURLRequest(net::URLRequest* request,
+                         const net::CompletionCallback& callback,
+                         GURL* new_url) override {
+    ++counters_["on_before_url_request_count"];
+    return net::OK;
+  }
+
+  void OnResolveProxy(const GURL& url,
+                      int load_flags,
+                      const net::ProxyService& proxy_service,
+                      net::ProxyInfo* result) override {
+    ++counters_["on_resolve_proxy_count"];
+  }
+
+  void OnProxyFallback(const net::ProxyServer& bad_proxy,
+                       int net_error) override {
+    ++counters_["on_proxy_fallback_count"];
+  }
+
+  int OnBeforeSendHeaders(net::URLRequest* request,
+                          const net::CompletionCallback& callback,
+                          net::HttpRequestHeaders* headers) override {
+    ++counters_["on_before_send_headers_count"];
+    return net::OK;
+  }
+
+  void OnBeforeSendProxyHeaders(net::URLRequest* request,
+                                const net::ProxyInfo& proxy_info,
+                                net::HttpRequestHeaders* headers) override {
+    ++counters_["on_before_send_proxy_headers_count"];
+  }
+
+  void OnSendHeaders(net::URLRequest* request,
+                     const net::HttpRequestHeaders& headers) override {
+
+    ++counters_["on_send_headers_count"];
+  }
+
+  int OnHeadersReceived(
+      net::URLRequest* request,
+      const net::CompletionCallback& callback,
+      const net::HttpResponseHeaders* original_response_headers,
+      scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
+      GURL* allowed_unsafe_redirect_url) override {
+    ++counters_["on_headers_received_count"];
+    return net::OK;
+  }
+
+  void OnBeforeRedirect(net::URLRequest* request,
+                        const GURL& new_location) override {
+    ++counters_["on_before_redirect_count"];
+  }
+
+  void OnResponseStarted(net::URLRequest* request) override {
+    ++counters_["on_response_started_count"];
+  }
+
+  void OnRawBytesRead(const net::URLRequest& request,
+                      int bytes_read) override {
+    ++counters_["on_raw_bytes_read_count"];
+  }
+
+  void OnCompleted(net::URLRequest* request, bool started) override {
+    ++counters_["on_completed_count"];
+  }
+
+  void OnURLRequestDestroyed(net::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(
+      net::URLRequest* request,
+      const net::AuthChallengeInfo& auth_info,
+      const AuthCallback& callback,
+      net::AuthCredentials* credentials) override {
+    ++counters_["on_auth_required_count"];
+    return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
+  }
+
+  bool OnCanGetCookies(const net::URLRequest& request,
+                       const net::CookieList& cookie_list) override {
+    ++counters_["on_can_get_cookies_count"];
+    return false;
+  }
+
+  bool OnCanSetCookie(const net::URLRequest& request,
+                      const std::string& cookie_line,
+                      net::CookieOptions* options) override {
+    ++counters_["on_can_set_cookie_count"];
+    return false;
+  }
+
+  CountersMap counters_;
+};
+
+class TestNetworkDelegateImplMock : public TestNetworkDelegateImpl {
+ public:
+  TestNetworkDelegateImplMock() {
+  }
+  virtual ~TestNetworkDelegateImplMock() {}
+
+  MOCK_CONST_METHOD2(OnCanAccessFile,
+                     bool(const net::URLRequest& request,
+                          const base::FilePath& path));
+
+  MOCK_CONST_METHOD1(OnCanThrottleRequest,
+                     bool(const net::URLRequest& request));
+
+  MOCK_CONST_METHOD2(OnCanEnablePrivacyMode,
+                     bool(const GURL& url,
+                          const GURL& first_party_for_cookies));
+
+  MOCK_CONST_METHOD3(
+      OnCancelURLRequestWithPolicyViolatingReferrerHeader,
+      bool(const net::URLRequest& request,
+           const GURL& target_url,
+           const GURL& referrer_url));
+};
+
+class WrappedNetworkDelegate : public net::WrappingNetworkDelegate {
+ public:
+  WrappedNetworkDelegate(scoped_ptr<net::NetworkDelegate> network_delegate)
+      : net::WrappingNetworkDelegate(network_delegate.Pass()),
+        context_(true) {
+    context_.Init();
+  }
+
+  virtual ~WrappedNetworkDelegate() {
+  }
+
+  void Call() {
+    scoped_refptr<net::AuthChallengeInfo> auth_challenge(
+        new net::AuthChallengeInfo());
+    scoped_ptr<net::URLRequest> request = context_.CreateRequest(
+        GURL(), net::IDLE, &delegate_, NULL);
+    OnBeforeURLRequest(NULL, net::CompletionCallback(), NULL);
+    OnResolveProxy(GURL(), 0,
+                   net::ProxyService(new TestProxyConfigService(), NULL, NULL),
+                   NULL);
+    OnProxyFallback(net::ProxyServer(), 0);
+    OnBeforeSendHeaders(NULL, net::CompletionCallback(), NULL);
+    OnBeforeSendProxyHeaders(NULL, net::ProxyInfo(), NULL);
+    OnSendHeaders(NULL, net::HttpRequestHeaders());
+    OnHeadersReceived(
+        NULL, net::CompletionCallback(), NULL, NULL, NULL);
+    OnBeforeRedirect(NULL, GURL());
+    OnResponseStarted(NULL);
+    OnRawBytesRead(*request.get(), 0);
+    OnCompleted(NULL, false);
+    OnURLRequestDestroyed(NULL);
+    OnPACScriptError(0, base::string16());
+    OnAuthRequired(NULL, *auth_challenge.get(), AuthCallback(), NULL);
+    OnCanGetCookies(*request.get(), net::CookieList());
+    OnCanSetCookie(*request.get(), std::string(), NULL);
+    OnCanAccessFile(*request.get(), base::FilePath());
+    OnCanThrottleRequest(*request.get());
+    OnCanEnablePrivacyMode(GURL(), GURL());
+    OnCancelURLRequestWithPolicyViolatingReferrerHeader(
+        *request.get(), GURL(), GURL());
+  }
+
+  void VerifyCalled(int64 count) {
+    VerifyCounters(counters_, count);
+  }
+
+ private:
+  void OnBeforeURLRequestInternal(net::URLRequest* request,
+                                  const net::CompletionCallback& callback,
+                                  GURL* new_url) override {
+    ++counters_["on_before_url_request_count"];
+  }
+
+  void OnResolveProxyInternal(const GURL& url,
+                              int load_flags,
+                              const net::ProxyService& proxy_service,
+                              net::ProxyInfo* result) override {
+    ++counters_["on_resolve_proxy_count"];
+  }
+
+  void OnProxyFallbackInternal(const net::ProxyServer& bad_proxy,
+                               int net_error) override {
+    ++counters_["on_proxy_fallback_count"];
+  }
+
+  void OnBeforeSendHeadersInternal(net::URLRequest* request,
+                                   const net::CompletionCallback& callback,
+                                   net::HttpRequestHeaders* headers) override {
+    ++counters_["on_before_send_headers_count"];
+  }
+
+  void OnBeforeSendProxyHeadersInternal(
+      net::URLRequest* request,
+      const net::ProxyInfo& proxy_info,
+      net::HttpRequestHeaders* headers) override {
+    ++counters_["on_before_send_proxy_headers_count"];
+  }
+
+  void OnSendHeadersInternal(net::URLRequest* request,
+                             const net::HttpRequestHeaders& headers) override {
+
+    ++counters_["on_send_headers_count"];
+  }
+
+  void OnHeadersReceivedInternal(
+      net::URLRequest* request,
+      const net::CompletionCallback& callback,
+      const net::HttpResponseHeaders* original_response_headers,
+      scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
+      GURL* allowed_unsafe_redirect_url) override {
+    ++counters_["on_headers_received_count"];
+  }
+
+  void OnBeforeRedirectInternal(net::URLRequest* request,
+                                const GURL& new_location) override {
+    ++counters_["on_before_redirect_count"];
+  }
+
+  void OnResponseStartedInternal(net::URLRequest* request) override {
+    ++counters_["on_response_started_count"];
+  }
+
+  void OnRawBytesReadInternal(const net::URLRequest& request,
+                              int bytes_read) override {
+    ++counters_["on_raw_bytes_read_count"];
+  }
+
+  void OnCompletedInternal(net::URLRequest* request, bool started) override {
+    ++counters_["on_completed_count"];
+  }
+
+  void OnURLRequestDestroyedInternal(net::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(net::URLRequest* request,
+                              const net::AuthChallengeInfo& auth_info,
+                              const AuthCallback& callback,
+                              net::AuthCredentials* credentials) override {
+    ++counters_["on_auth_required_count"];
+  }
+
+  void OnCanGetCookiesInternal(const net::URLRequest& request,
+                               const net::CookieList& cookie_list) override {
+    ++counters_["on_can_get_cookies_count"];
+  }
+
+  void OnCanSetCookieInternal(const net::URLRequest& request,
+                              const std::string& cookie_line,
+                              net::CookieOptions* options) override {
+    ++counters_["on_can_set_cookie_count"];
+  }
+
+  net::TestURLRequestContext context_;
+  net::TestDelegate delegate_;
+  CountersMap counters_;
+};
+
+class WrappedNetworkDelegateMock : public WrappedNetworkDelegate {
+ public:
+  WrappedNetworkDelegateMock(scoped_ptr<NetworkDelegate> network_delegate)
+      : WrappedNetworkDelegate(network_delegate.Pass()) {}
+  virtual ~WrappedNetworkDelegateMock() {}
+
+  MOCK_CONST_METHOD2(OnCanAccessFileInternal,
+                     void(const net::URLRequest& request,
+                          const base::FilePath& path));
+
+  MOCK_CONST_METHOD1(OnCanThrottleRequestInternal,
+                     void(const net::URLRequest& request));
+
+  MOCK_CONST_METHOD2(OnCanEnablePrivacyModeInternal,
+                     void(const GURL& url,
+                          const GURL& first_party_for_cookies));
+
+  MOCK_CONST_METHOD3(
+      OnCancelURLRequestWithPolicyViolatingReferrerHeaderInternal,
+      void(const net::URLRequest& request,
+           const GURL& target_url,
+           const GURL& referrer_url));
+};
+
+}  // namespace
+
+namespace net {
+
+class WrappingNetworkDelegateTest : public testing::Test {
+ public:
+  WrappingNetworkDelegateTest() {
+    scoped_ptr<TestNetworkDelegateImplMock> test_network_delegate(
+        new TestNetworkDelegateImplMock());
+    test_network_delegate_ = test_network_delegate.get();
+    wrapped_network_delegate_ = scoped_ptr<WrappedNetworkDelegateMock>(
+       new WrappedNetworkDelegateMock(test_network_delegate.Pass()));
+  }
+
+  TestNetworkDelegateImplMock* test_network_delegate_;
+  scoped_ptr<WrappedNetworkDelegateMock> wrapped_network_delegate_;
+};
+
+TEST_F(WrappingNetworkDelegateTest, VerifyWrappingNetworkDelegateInternal) {
+  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(*wrapped_network_delegate_.get(),
+              OnCanAccessFileInternal(testing::_, testing::_));
+  EXPECT_CALL(*wrapped_network_delegate_.get(),
+              OnCanThrottleRequestInternal(testing::_));
+  EXPECT_CALL(*wrapped_network_delegate_.get(),
+              OnCanEnablePrivacyModeInternal(testing::_, testing::_));
+  EXPECT_CALL(*wrapped_network_delegate_.get(),
+              OnCancelURLRequestWithPolicyViolatingReferrerHeaderInternal(
+                  testing::_, testing::_, testing::_));
+
+  wrapped_network_delegate_->Call();
+
+  test_network_delegate_->VerifyCalled(1);
+  wrapped_network_delegate_->VerifyCalled(1);
+}
+
+}  // namespace net