Merge 273839 "Update UMA to track bypasses due to 4xx responses ..."

net/proxy/proxy_service.h

 // 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.
 
 #ifndef NET_PROXY_PROXY_SERVICE_H_
 #define NET_PROXY_PROXY_SERVICE_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 114 matching lines @@
   // Profiling information for the request is saved to |net_log| if non-NULL.
   int ResolveProxy(const GURL& url,
                    ProxyInfo* results,
                    const net::CompletionCallback& callback,
                    PacRequest** pac_request,
                    const BoundNetLog& net_log);
 
   // This method is called after a failure to connect or resolve a host name.
   // It gives the proxy service an opportunity to reconsider the proxy to use.
   // The |results| parameter contains the results returned by an earlier call
-  // to ResolveProxy.  The semantics of this call are otherwise similar to
-  // ResolveProxy.
+  // to ResolveProxy.  The |net_error| parameter contains the network error
+  // code associated with the failure. See "net/base/net_error_list.h" for a
+  // list of possible values. The semantics of this call are otherwise
+  // similar to ResolveProxy.
   //
   // NULL can be passed for |pac_request| if the caller will not need to
   // cancel the request.
   //
   // Returns ERR_FAILED if there is not another proxy config to try.
   //
   // Profiling information for the request is saved to |net_log| if non-NULL.
   int ReconsiderProxyAfterError(const GURL& url,
+                                int net_error,
                                 ProxyInfo* results,
                                 const CompletionCallback& callback,
                                 PacRequest** pac_request,
                                 const BoundNetLog& net_log);
 
   // Explicitly trigger proxy fallback for the given |results| by updating our
   // list of bad proxies to include the first entry of |results|, and,
   // optionally, another bad proxy. Will retry after |retry_delay| if positive,
   // and will use the default proxy retry duration otherwise. Proxies marked as
   // bad will not be retried until |retry_delay| has passed. Returns true if
@@ skipping 124 matching lines @@
 
     // Bypass the proxy because of an internal server error.
     INTERNAL_SERVER_ERROR_BYPASS,
 
     // Bypass the proxy because of any other error.
     ERROR_BYPASS,
 
     // Bypass the proxy because responses appear not to be coming via it.
     MISSING_VIA_HEADER,
 
+    // Bypass the proxy because the proxy, not the origin, sent a 4xx response.
+    PROXY_4XX_BYPASS,
+
     // This must always be last.
     BYPASS_EVENT_TYPE_MAX
   };
 
   // Records a |DataReductionProxyBypassEventType| for either the data reduction
   // proxy (|is_primary| is true) or the data reduction proxy fallback.
   void RecordDataReductionProxyBypassInfo(
       bool is_primary,
       const ProxyServer& proxy_server,
       DataReductionProxyBypassEventType bypass_type) const;
+
+  // Records a net error code that resulted in bypassing the data reduction
+  // proxy (|is_primary| is true) or the data reduction proxy fallback.
+  void RecordDataReductionProxyBypassOnNetworkError(
+      bool is_primary,
+      const ProxyServer& proxy_server,
+      int net_error);
 #endif
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ProxyServiceTest, UpdateConfigAfterFailedAutodetect);
   FRIEND_TEST_ALL_PREFIXES(ProxyServiceTest, UpdateConfigFromPACToDirect);
   friend class PacRequest;
   class InitProxyResolver;
   class ProxyScriptDeciderPoller;
 
   // TODO(eroman): change this to a std::set. Note that this requires updating
@@ skipping 142 matching lines @@
 class NET_EXPORT SyncProxyServiceHelper
     : public base::RefCountedThreadSafe<SyncProxyServiceHelper> {
  public:
   SyncProxyServiceHelper(base::MessageLoop* io_message_loop,
                          ProxyService* proxy_service);
 
   int ResolveProxy(const GURL& url,
                    ProxyInfo* proxy_info,
                    const BoundNetLog& net_log);
   int ReconsiderProxyAfterError(const GURL& url,
+                                int net_error,
                                 ProxyInfo* proxy_info,
                                 const BoundNetLog& net_log);
 
  private:
   friend class base::RefCountedThreadSafe<SyncProxyServiceHelper>;
 
   virtual ~SyncProxyServiceHelper();
 
   void StartAsyncResolve(const GURL& url, const BoundNetLog& net_log);
-  void StartAsyncReconsider(const GURL& url, const BoundNetLog& net_log);
+  void StartAsyncReconsider(const GURL& url,
+                            int net_error,
+                            const BoundNetLog& net_log);
 
   void OnCompletion(int result);
 
   base::MessageLoop* io_message_loop_;
   ProxyService* proxy_service_;
 
   base::WaitableEvent event_;
   CompletionCallback callback_;
   ProxyInfo proxy_info_;
   int result_;
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_PROXY_SERVICE_H_