Use data reduction proxy when managed proxy config returns direct

net/proxy/proxy_service_unittest.cc

 // Copyright (c) 2012 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/proxy/proxy_service.h"
 
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 143 matching lines @@
   ProxyConfig config_;
   ObserverList<Observer, true> observers_;
 };
 
 // A test network delegate that exercises the OnResolveProxy callback.
 class TestResolveProxyNetworkDelegate : public NetworkDelegate {
  public:
   TestResolveProxyNetworkDelegate()
       : on_resolve_proxy_called_(false),
         add_proxy_(false),
-        remove_proxy_(false) {
+        remove_proxy_(false),
+        proxy_service_(NULL) {
   }
 
-  virtual void OnResolveProxy(
-      const GURL& url, int load_flags, ProxyInfo* result) OVERRIDE {
+  virtual void OnResolveProxy(const GURL& url,
+                              int load_flags,
+                              const ProxyService& proxy_service,
+                              ProxyInfo* result) OVERRIDE {
     on_resolve_proxy_called_ = true;
+    proxy_service_ = &proxy_service;
     DCHECK(!add_proxy_ || !remove_proxy_);
     if (add_proxy_) {
       result->UseNamedProxy("delegate_proxy.com");
     } else if (remove_proxy_) {
       result->UseDirect();
     }
   }
 
   bool on_resolve_proxy_called() const {
     return on_resolve_proxy_called_;
   }
 
   void set_add_proxy(bool add_proxy) {
     add_proxy_ = add_proxy;
   }
 
   void set_remove_proxy(bool remove_proxy) {
     remove_proxy_ = remove_proxy;
   }
 
+  const ProxyService* proxy_service() const {
+    return proxy_service_;
+  }
+
  private:
   bool on_resolve_proxy_called_;
   bool add_proxy_;
   bool remove_proxy_;
+  const ProxyService* proxy_service_;
 };
 
 // A test network delegate that exercises the OnProxyFallback callback.
 class TestProxyFallbackNetworkDelegate : public NetworkDelegate {
  public:
   TestProxyFallbackNetworkDelegate()
       : on_proxy_fallback_called_(false),
         proxy_fallback_net_error_(0),
         proxy_did_fallback_(false) {
   }
@@ skipping 88 matching lines @@
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, NULL,
       log.bound());
   EXPECT_EQ(OK, rv);
 
   // Verify that network delegate is invoked.
   TestResolveProxyNetworkDelegate delegate;
   rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, &delegate,
       log.bound());
   EXPECT_TRUE(delegate.on_resolve_proxy_called());
+  EXPECT_EQ(&service, delegate.proxy_service());
 
   // Verify that the NetworkDelegate's behavior is stateless across
   // invocations of ResolveProxy. Start by having the callback add a proxy
   // and checking that subsequent requests are not affected.
   delegate.set_add_proxy(true);
 
   // Callback should interpose:
   rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, &delegate,
       log.bound());
@@ skipping 2783 matching lines @@
   ProxyInfo info3;
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(
       GURL("http://request3"), net::LOAD_NORMAL, &info3, callback3.callback(),
       NULL, NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(info3.is_direct());
 }
 
 }  // namespace net