Add retry and lasterror parameters to DMServer requests.

components/policy/core/common/cloud/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 "components/policy/core/common/cloud/device_management_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 202 matching lines @@
 
   // 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 connection errors.
   int retries_count_;
 
+  // The last error why we had to retry.
+  int last_error_ = 0;
+
   // The request context to use for this job.
   scoped_refptr<net::URLRequestContextGetter> request_context_;
 
   // Used to get notified if the job has been canceled while waiting for retry.
   base::WeakPtrFactory<DeviceManagementRequestJobImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementRequestJobImpl);
 };
 
 DeviceManagementRequestJobImpl::DeviceManagementRequestJobImpl(
@@ skipping 88 matching lines @@
       else
         ReportError(DM_STATUS_HTTP_STATUS_ERROR);
       return;
   }
 }
 
 GURL DeviceManagementRequestJobImpl::GetURL(
     const std::string& server_url) {
   std::string result(server_url);
   result += '?';
-  for (ParameterMap::const_iterator entry(query_params_.begin());
-       entry != query_params_.end();
-       ++entry) {
-    if (entry != query_params_.begin())
+  ParameterMap current_query_params(query_params_);
+  if (last_error_ == 0) {
+    // Not a retry.
+    current_query_params.push_back(
+        std::make_pair(dm_protocol::kParamRetry, "false"));

[Andrew T Wilson (Slow), 2016/10/13 14:03:13]

This is fine, or you could just omit it.

[Marton Hunyady, 2016/10/13 14:17:19]

I planned to send it so we see immediately (without checking the version) if
it's the first fetch or a retry from an old version of Chrome which doesn't send
the parameter yet.

+  } else {
+    current_query_params.push_back(
+        std::make_pair(dm_protocol::kParamRetry, "true"));
+    current_query_params.push_back(std::make_pair(dm_protocol::kParamLastError,
+                                                  std::to_string(last_error_)));
+  }
+  for (ParameterMap::const_iterator entry(current_query_params.begin());
+       entry != current_query_params.end(); ++entry) {
+    if (entry != current_query_params.begin())
       result += '&';
     result += net::EscapeQueryParamValue(entry->first, true);
     result += '=';
     result += net::EscapeQueryParamValue(entry->second, true);
   }
   return GURL(result);
 }
 
 void DeviceManagementRequestJobImpl::ConfigureRequest(
     net::URLFetcher* fetcher) {
@@ skipping 10 matching lines @@
   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);
 }
 
 DeviceManagementRequestJobImpl::RetryMethod
 DeviceManagementRequestJobImpl::ShouldRetry(const net::URLFetcher* fetcher) {
+  last_error_ = fetcher->GetStatus().error();
   if (FailedWithProxy(fetcher) && !bypass_proxy_) {
     // Retry the job immediately if it failed due to a broken proxy, by
     // bypassing the proxy on the next try.
     bypass_proxy_ = true;
     return RETRY_IMMEDIATELY;
   }
 
   // Early device policy fetches on ChromeOS and Auto-Enrollment checks are
   // often interrupted during ChromeOS startup when network is not yet ready.
   // Allowing the fetcher to retry once after that is enough to recover; allow
@@ skipping 235 matching lines @@
     }
   }
 
   const JobQueue::iterator elem =
       std::find(queued_jobs_.begin(), queued_jobs_.end(), job);
   if (elem != queued_jobs_.end())
     queued_jobs_.erase(elem);
 }
 
 }  // namespace policy