Add data reduction functionality to all platforms.

net/proxy/proxy_service.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 <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 1188 matching lines @@
 
   bool re_resolve = result->config_id_ != config_.id();
 
   if (re_resolve) {
     // If we have a new config or the config was never tried, we delete the
     // list of bad proxies and we try again.
     proxy_retry_info_.clear();
     return ResolveProxy(url, load_flags, result, callback, pac_request,
                         network_delegate, net_log);
   }
-
-#if defined(SPDY_PROXY_AUTH_ORIGIN)
-  if (result->proxy_server().isDataReductionProxy()) {
-    RecordDataReductionProxyBypassInfo(
-        true, false, result->proxy_server(), NETWORK_ERROR);
-    RecordDataReductionProxyBypassOnNetworkError(
-        true, result->proxy_server(), net_error);
-  } else if (result->proxy_server().isDataReductionProxyFallback()) {
-    RecordDataReductionProxyBypassInfo(
-        false, false, result->proxy_server(), NETWORK_ERROR);
-    RecordDataReductionProxyBypassOnNetworkError(
-        false, result->proxy_server(), net_error);
+  const net::ProxyServer& proxy_server = result->proxy_server();

[bengr, 2014/07/18 19:41:44]

Instead of doing it this way, it would probably be better to embed a Callback or
delegate. Add a TODO to do it that way.

For example, you could do:

callback_.Run(result);

Then ProxyService wouldn't need to know what a data reduction proxy is.

[Not at Google. Contact bengr, 2014/07/21 17:46:26]

Good idea. I went down the path of trying to do it in this cl. But it caused
some cascading changes which makes the cl too big. Added TODO.

+  if (proxy_server.is_valid() && !proxy_server.is_direct()) {
+    if (proxy_server.host_port_pair().Equals(
+        data_reduction_default_origin_)) {
+      RecordDataReductionProxyBypassInfo(
+          true, false, proxy_server, NETWORK_ERROR);
+      RecordDataReductionProxyBypassOnNetworkError(
+          true, proxy_server, net_error);
+    } else if (proxy_server.host_port_pair().Equals(
+        data_reduction_default_fallback_origin_)) {
+      RecordDataReductionProxyBypassInfo(
+          false, false, proxy_server, NETWORK_ERROR);
+      RecordDataReductionProxyBypassOnNetworkError(
+          false, proxy_server, net_error);
+    }
   }
-#endif
 
   // We don't have new proxy settings to try, try to fallback to the next proxy
   // in the list.
   bool did_fallback = result->Fallback(net_log);
 
   // Return synchronous failure if there is nothing left to fall-back to.
   // TODO(eroman): This is a yucky API, clean it up.
   return did_fallback ? OK : ERR_FAILED;
 }
 
@@ skipping 158 matching lines @@
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::ForceReloadProxyConfig() {
   DCHECK(CalledOnValidThread());
   ResetProxyConfig(false);
   ApplyProxyConfigIfAvailable();
 }
 
+void ProxyService::SetDataReductionProxyOrigins(
+    const std::string& data_reduction_default_origin,
+    const std::string& data_reduction_default_fallback_origin) {
+  DCHECK(CalledOnValidThread());
+  data_reduction_default_origin_ =
+      net::HostPortPair::FromURL(GURL(data_reduction_default_origin));
+  data_reduction_default_fallback_origin_ =
+      net::HostPortPair::FromURL(GURL(data_reduction_default_fallback_origin));
+
+}
+
 // static
 ProxyConfigService* ProxyService::CreateSystemProxyConfigService(
     base::SingleThreadTaskRunner* io_thread_task_runner,
     base::MessageLoop* file_loop) {
 #if defined(OS_WIN)
   return new ProxyConfigServiceWin();
 #elif defined(OS_IOS)
   return new ProxyConfigServiceIOS();
 #elif defined(OS_MACOSX)
   return new ProxyConfigServiceMac(io_thread_task_runner);
@@ skipping 199 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net