Fix cloud policy duplicate registrations issue.

chrome/browser/policy/device_management_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 "chrome/browser/policy/device_management_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 35 matching lines @@
 namespace {
 
 const char kValueAgent[] = "%s %s(%s)";
 const char kValuePlatform[] = "%s|%s|%s";
 
 const char kPostContentType[] = "application/protobuf";
 
 const char kServiceTokenAuthHeader[] = "Authorization: GoogleLogin auth=";
 const char kDMTokenAuthHeader[] = "Authorization: GoogleDMToken token=";
 
+// Number of times to retry on ERR_NETWORK_CHANGED errors.
+const int kMaxNetworkChangedRetries = 3;
+
 // HTTP Error Codes of the DM Server with their concrete meanings in the context
 // of the DM Server communication.
 const int kSuccess = 200;
 const int kInvalidArgument = 400;
 const int kInvalidAuthCookieOrDMToken = 401;
 const int kMissingLicenses = 402;
 const int kDeviceManagementNotAllowed = 403;
 const int kInvalidURL = 404;  // This error is not coming from the GFE.
 const int kInvalidSerialNumber = 405;
 const int kDeviceIdConflict = 409;
@@ skipping 17 matching lines @@
     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 net::URLFetcher* source) {
-  return source->GetResponseHeaders()->HasHeaderValue(
+bool IsProtobufMimeType(const net::URLFetcher* fetcher) {
+  return fetcher->GetResponseHeaders()->HasHeaderValue(
       "content-type", "application/x-protobuffer");
 }
 
+bool FailedWithProxy(const net::URLFetcher* fetcher) {
+  if ((fetcher->GetLoadFlags() & net::LOAD_BYPASS_PROXY) != 0) {
+    // The request didn't use a proxy.
+    return false;
+  }
+
+  if (!fetcher->GetStatus().is_success() &&
+      IsProxyError(fetcher->GetStatus())) {
+    LOG(WARNING) << "Proxy failed while contacting dmserver.";
+    return true;
+  }
+
+  if (fetcher->GetStatus().is_success() &&
+      fetcher->GetResponseCode() == kSuccess &&
+      fetcher->WasFetchedViaProxy() &&
+      !IsProtobufMimeType(fetcher)) {
+    // 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.";
+    return true;
+  }
+
+  return false;
+}
+
 const char* UserAffiliationToString(UserAffiliation affiliation) {
   switch (affiliation) {
     case USER_AFFILIATION_MANAGED:
       return dm_protocol::kValueUserAffiliationManaged;
     case USER_AFFILIATION_NONE:
       return dm_protocol::kValueUserAffiliationNone;
   }
   NOTREACHED() << "Invalid user affiliation " << affiliation;
   return dm_protocol::kValueUserAffiliationNone;
 }
@@ skipping 160 matching lines @@
                       int response_code,
                       const net::ResponseCookies& cookies,
                       const std::string& data);
 
   // Gets the URL to contact.
   GURL GetURL(const std::string& server_url);
 
   // Configures the fetcher, setting up payload and headers.
   void ConfigureRequest(net::URLFetcher* fetcher);
 
+  // Returns true if this job should be retried. |fetcher| has just completed,
+  // and can be inspected to determine if the request failed and should be
+  // retried.
+  bool ShouldRetry(const net::URLFetcher* fetcher);
+
+  // Invoked right before retrying this job.
+  void PrepareRetry();
+
  protected:
   // DeviceManagementRequestJob:
   virtual void Run() OVERRIDE;
 
  private:
   // Invokes the callback with the given error code.
   void ReportError(DeviceManagementStatus code);
 
   // Pointer to the service this job is associated with.
   DeviceManagementService* service_;
 
+  // Whether the BYPASS_PROXY flag should be set by ConfigureRequest().
+  bool bypass_proxy_;
+
+  // Number of times that this job has been retried due to ERR_NETWORK_CHANGED.
+  int retries_count_;
+
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementRequestJobImpl);
 };
 
 DeviceManagementRequestJobImpl::DeviceManagementRequestJobImpl(
     JobType type,
     DeviceManagementService* service)
     : DeviceManagementRequestJob(type),
-      service_(service) {}
+      service_(service),
+      bypass_proxy_(false),
+      retries_count_(0) {}
 
 DeviceManagementRequestJobImpl::~DeviceManagementRequestJobImpl() {
   service_->RemoveJob(this);
 }
 
 void DeviceManagementRequestJobImpl::Run() {
   service_->AddJob(this);
 }
 
 void DeviceManagementRequestJobImpl::HandleResponse(
@@ skipping 75 matching lines @@
       result += '&';
     result += net::EscapeQueryParamValue(entry->first, true);
     result += '=';
     result += net::EscapeQueryParamValue(entry->second, true);
   }
   return GURL(result);
 }
 
 void DeviceManagementRequestJobImpl::ConfigureRequest(
     net::URLFetcher* fetcher) {
+  fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
+                        net::LOAD_DO_NOT_SAVE_COOKIES |
+                        net::LOAD_DISABLE_CACHE |
+                        (bypass_proxy_ ? net::LOAD_BYPASS_PROXY : 0));
   std::string payload;
   CHECK(request_.SerializeToString(&payload));
   fetcher->SetUploadData(kPostContentType, payload);
   std::string extra_headers;
   if (!gaia_token_.empty())
     extra_headers += kServiceTokenAuthHeader + gaia_token_ + "\n";
   if (!dm_token_.empty())
     extra_headers += kDMTokenAuthHeader + dm_token_ + "\n";
   fetcher->SetExtraRequestHeaders(extra_headers);
 }
 
+bool DeviceManagementRequestJobImpl::ShouldRetry(
+    const net::URLFetcher* fetcher) {
+  if (FailedWithProxy(fetcher) && !bypass_proxy_) {
+    // Retry the job if it failed due to a broken proxy, by bypassing the
+    // proxy on the next try.
+    bypass_proxy_ = true;
+    return true;
+  }
+
+  // Early device policy fetches on ChromeOS and Auto-Enrollment checks are
+  // often interrupted during ChromeOS startup when network change notifications
+  // are sent. Allowing the fetcher to retry once after that is enough to
+  // recover; allow it to retry up to 3 times just in case.
+  if (fetcher->GetStatus().error() == net::ERR_NETWORK_CHANGED &&
+      retries_count_ < kMaxNetworkChangedRetries) {
+    ++retries_count_;
+    return true;
+  }
+
+  // The request didn't fail, or the limit of retry attempts has been reached;
+  // forward the result to the job owner.
+  return false;
+}
+
+void DeviceManagementRequestJobImpl::PrepareRetry() {
+  if (!retry_callback_.is_null())
+    retry_callback_.Run(this);
+}
+
 void DeviceManagementRequestJobImpl::ReportError(DeviceManagementStatus code) {
   em::DeviceManagementResponse dummy_response;
   callback_.Run(code, dummy_response);
 }
 
 DeviceManagementRequestJob::~DeviceManagementRequestJob() {}
 
 void DeviceManagementRequestJob::SetGaiaToken(const std::string& gaia_token) {
   gaia_token_ = gaia_token;
 }
@@ skipping 21 matching lines @@
 }
 
 DeviceManagementRequestJob::DeviceManagementRequestJob(JobType type) {
   AddParameter(dm_protocol::kParamRequest, JobTypeToRequestType(type));
   AddParameter(dm_protocol::kParamDeviceType, dm_protocol::kValueDeviceType);
   AddParameter(dm_protocol::kParamAppType, dm_protocol::kValueAppType);
   AddParameter(dm_protocol::kParamAgent, GetAgentString());
   AddParameter(dm_protocol::kParamPlatform, GetPlatformString());
 }
 
+void DeviceManagementRequestJob::SetRetryCallback(
+    const RetryCallback& retry_callback) {
+  retry_callback_ = retry_callback;
+}
+
 void DeviceManagementRequestJob::Start(const Callback& callback) {
   callback_ = callback;
   Run();
 }
 
 void DeviceManagementRequestJob::AddParameter(const std::string& name,
                                               const std::string& value) {
   query_params_.push_back(std::make_pair(name, value));
 }
 
+// A random value that other fetchers won't likely use.
+const int DeviceManagementService::kURLFetcherID = 0xde71ce1d;
+
 DeviceManagementService::~DeviceManagementService() {
   // All running jobs should have been cancelled by now.
   DCHECK(pending_jobs_.empty());
   DCHECK(queued_jobs_.empty());
 }
 
 DeviceManagementRequestJob* DeviceManagementService::CreateJob(
     DeviceManagementRequestJob::JobType type) {
   return new DeviceManagementRequestJobImpl(type, this);
 }
@@ skipping 10 matching lines @@
 
 void DeviceManagementService::Initialize() {
   if (initialized_)
     return;
   DCHECK(!request_context_getter_);
   request_context_getter_ = new DeviceManagementRequestContextGetter(
       g_browser_process->system_request_context());
   initialized_ = true;
 
   while (!queued_jobs_.empty()) {
-    StartJob(queued_jobs_.front(), false);
+    StartJob(queued_jobs_.front());
     queued_jobs_.pop_front();
   }
 }
 
 void DeviceManagementService::Shutdown() {
   for (JobFetcherMap::iterator job(pending_jobs_.begin());
        job != pending_jobs_.end();
        ++job) {
     delete job->first;
     queued_jobs_.push_back(job->second);
   }
   pending_jobs_.clear();
 }
 
 DeviceManagementService::DeviceManagementService(
     const std::string& server_url)
     : server_url_(server_url),
       initialized_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
-void DeviceManagementService::StartJob(DeviceManagementRequestJobImpl* job,
-                                       bool bypass_proxy) {
+void DeviceManagementService::StartJob(DeviceManagementRequestJobImpl* job) {
   net::URLFetcher* fetcher = net::URLFetcher::Create(
-      0, job->GetURL(server_url_), net::URLFetcher::POST, this);
-  fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
-                        net::LOAD_DO_NOT_SAVE_COOKIES |
-                        net::LOAD_DISABLE_CACHE |
-                        (bypass_proxy ? net::LOAD_BYPASS_PROXY : 0));
+      kURLFetcherID, job->GetURL(server_url_), net::URLFetcher::POST, this);
   fetcher->SetRequestContext(request_context_getter_.get());
-  // Early device policy fetches on ChromeOS and Auto-Enrollment checks are
-  // often interrupted during ChromeOS startup when network change notifications
-  // are sent. Allowing the fetcher to retry once after that is enough to
-  // recover; allow it to retry up to 3 times just in case.
-  // http://crosbug.com/16114
-  fetcher->SetAutomaticallyRetryOnNetworkChanges(3);
   job->ConfigureRequest(fetcher);
   pending_jobs_[fetcher] = job;
   fetcher->Start();
 }
 
 void DeviceManagementService::OnURLFetchComplete(
     const net::URLFetcher* source) {
   JobFetcherMap::iterator entry(pending_jobs_.find(source));
   if (entry == pending_jobs_.end()) {
     NOTREACHED() << "Callback from foreign URL fetcher";
     return;
   }
 
   DeviceManagementRequestJobImpl* 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.
-  bool retry = false;
-  if ((source->GetLoadFlags() & net::LOAD_BYPASS_PROXY) == 0) {
-    if (!source->GetStatus().is_success() &&
-        IsProxyError(source->GetStatus())) {
-      LOG(WARNING) << "Proxy failed while contacting dmserver.";
-      retry = true;
-    } else if (source->GetStatus().is_success() &&
-               source->GetResponseCode() == kSuccess &&
-               source->WasFetchedViaProxy() &&
-               !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);
+  if (job->ShouldRetry(source)) {
+    VLOG(1) << "Retrying dmserver request.";
+    job->PrepareRetry();
+    StartJob(job);
   } else {
     std::string data;
     source->GetResponseAsString(&data);
     job->HandleResponse(source->GetStatus(), source->GetResponseCode(),
                         source->GetCookies(), data);
   }
   delete source;
 }
 
 void DeviceManagementService::AddJob(DeviceManagementRequestJobImpl* job) {
   if (initialized_)
-    StartJob(job, false);
+    StartJob(job);
   else
     queued_jobs_.push_back(job);
 }
 
 void DeviceManagementService::RemoveJob(DeviceManagementRequestJobImpl* job) {
   for (JobFetcherMap::iterator entry(pending_jobs_.begin());
        entry != pending_jobs_.end();
        ++entry) {
     if (entry->second == job) {
       delete entry->first;
       pending_jobs_.erase(entry);
       return;
     }
   }
 
   const JobQueue::iterator elem =
       std::find(queued_jobs_.begin(), queued_jobs_.end(), job);
   if (elem != queued_jobs_.end())
     queued_jobs_.erase(elem);
 }
 
 }  // namespace policy