Recover from bad proxy settings pointing to non-proxy servers that reply anyway.

chrome/browser/policy/device_management_service.cc

 // Copyright (c) 2011 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 "chrome/browser/policy/device_management_service.h"
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/policy/device_management_backend.h"
 #include "chrome/browser/policy/device_management_backend_impl.h"
 #include "content/browser/browser_thread.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/host_resolver.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/http/http_network_layer.h"
+#include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "webkit/glue/webkit_glue.h"
 
 namespace policy {
 
 namespace {
 
+bool IsProxyError(const net::URLRequestStatus status) {
+  switch (status.error()) {
+    case net::ERR_PROXY_CONNECTION_FAILED:
+    case net::ERR_TUNNEL_CONNECTION_FAILED:
+    case net::ERR_PROXY_AUTH_UNSUPPORTED:
+    case net::ERR_HTTPS_PROXY_TUNNEL_RESPONSE:
+    case net::ERR_MANDATORY_PROXY_CONFIGURATION_FAILED:
+    case net::ERR_PROXY_CERTIFICATE_INVALID:
+    case net::ERR_SOCKS_CONNECTION_FAILED:
+    case net::ERR_SOCKS_CONNECTION_HOST_UNREACHABLE:
+      return true;
+  }
+  return false;
+}
+
+bool IsProtobufMimeType(const URLFetcher* source) {
+  return source->response_headers()->HasHeaderValue(
+      "content-type", "application/x-protobuffer");
+}
+
 // Custom request context implementation that allows to override the user agent,
 // amongst others. Wraps a baseline request context from which we reuse the
 // networking components.
 class DeviceManagementRequestContext : public net::URLRequestContext {
  public:
   explicit DeviceManagementRequestContext(net::URLRequestContext* base_context);
   virtual ~DeviceManagementRequestContext();
 
  private:
   // Overridden from net::URLRequestContext:
@@ skipping 167 matching lines @@
     const net::ResponseCookies& cookies,
     const std::string& data) {
   JobFetcherMap::iterator entry(pending_jobs_.find(source));
   if (entry != pending_jobs_.end()) {
     DeviceManagementJob* job = entry->second;
     pending_jobs_.erase(entry);
 
     // Retry the job if it failed due to a broken proxy, by bypassing the
     // proxy on the next try. Don't retry if this URLFetcher already bypassed
     // the proxy.
-    int error = status.error();
-    if (!status.is_success() &&
-        ((source->load_flags() & net::LOAD_BYPASS_PROXY) == 0) &&
-        (error == net::ERR_PROXY_CONNECTION_FAILED ||
-         error == net::ERR_TUNNEL_CONNECTION_FAILED ||
-         error == net::ERR_PROXY_AUTH_UNSUPPORTED ||
-         error == net::ERR_HTTPS_PROXY_TUNNEL_RESPONSE ||
-         error == net::ERR_MANDATORY_PROXY_CONFIGURATION_FAILED ||
-         error == net::ERR_PROXY_CERTIFICATE_INVALID ||
-         error == net::ERR_SOCKS_CONNECTION_FAILED ||
-         error == net::ERR_SOCKS_CONNECTION_HOST_UNREACHABLE)) {
-      LOG(WARNING) << "Proxy failed while contacting dmserver. Retrying "
-                   << "without using the proxy.";
+    bool retry = false;
+    if ((source->load_flags() & net::LOAD_BYPASS_PROXY) == 0) {
+      if (!status.is_success() && IsProxyError(status)) {
+        LOG(WARNING) << "Proxy failed while contacting dmserver.";
+        retry = true;
+      } else if (status.is_success() &&
+                 source->was_fetched_via_proxy() &&
+                 !IsProtobufMimeType(source)) {
+        // The proxy server can be misconfigured but pointing to an existing
+        // server that replies to requests. Try to recover if a successful
+        // request that went through a proxy returns an unexpected mime type.
+        LOG(WARNING) << "Got bad mime-type in response from dmserver that was "
+                     << "fetched via a proxy.";
+        retry = true;
+      }
+    }
+
+    if (retry) {
+      LOG(WARNING) << "Retrying dmserver request without using a proxy.";
       StartJob(job, true);
     } else {
       job->HandleResponse(status, response_code, cookies, data);
     }
   } else {
     NOTREACHED() << "Callback from foreign URL fetcher";
   }
   delete source;
 }
 
 }  // namespace policy