[GCM] Adding basic G-services handling

google_apis/gcm/engine/checkin_request.cc

 // Copyright 2014 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 "google_apis/gcm/engine/checkin_request.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "google_apis/gcm/protocol/checkin.pb.h"
@@ skipping 28 matching lines @@
   // histogram enum accordingly.
   STATUS_COUNT
 };
 
 void RecordCheckinStatusToUMA(CheckinRequestStatus status) {
   UMA_HISTOGRAM_ENUMERATION("GCM.CheckinRequestStatus", status, STATUS_COUNT);
 }
 
 }  // namespace
 
-CheckinRequest::CheckinRequest(
-    const CheckinRequestCallback& callback,
-    const net::BackoffEntry::Policy& backoff_policy,
-    const checkin_proto::ChromeBuildProto& chrome_build_proto,
+CheckinRequest::RequestInfo::RequestInfo(
     uint64 android_id,
     uint64 security_token,
+    const std::string& settings_digest,
     const std::vector<std::string>& account_ids,
+    const checkin_proto::ChromeBuildProto& chrome_build_proto)
+    : android_id(android_id),
+      security_token(security_token),
+      settings_digest(settings_digest),
+      account_ids(account_ids),
+      chrome_build_proto(chrome_build_proto) {
+}
+
+CheckinRequest::RequestInfo::~RequestInfo() {}
+
+CheckinRequest::CheckinRequest(
+    const RequestInfo& request_info,
+    const net::BackoffEntry::Policy& backoff_policy,
+    const CheckinRequestCallback& callback,
     net::URLRequestContextGetter* request_context_getter)
     : request_context_getter_(request_context_getter),
       callback_(callback),
       backoff_entry_(&backoff_policy),
-      chrome_build_proto_(chrome_build_proto),
-      android_id_(android_id),
-      security_token_(security_token),
-      account_ids_(account_ids),
+      request_info_(request_info),
       weak_ptr_factory_(this) {
 }
 
 CheckinRequest::~CheckinRequest() {}
 
 void CheckinRequest::Start() {
   DCHECK(!url_fetcher_.get());
 
   checkin_proto::AndroidCheckinRequest request;
-  request.set_id(android_id_);
-  request.set_security_token(security_token_);
+  request.set_id(request_info_.android_id);
+  request.set_security_token(request_info_.security_token);
   request.set_user_serial_number(kDefaultUserSerialNumber);
   request.set_version(kRequestVersionValue);
+  if (!request_info_.settings_digest.empty())
+    request.set_digest(request_info_.settings_digest);
 
   checkin_proto::AndroidCheckinProto* checkin = request.mutable_checkin();
-  checkin->mutable_chrome_build()->CopyFrom(chrome_build_proto_);
+  checkin->mutable_chrome_build()->CopyFrom(request_info_.chrome_build_proto);
 #if defined(CHROME_OS)
   checkin->set_type(checkin_proto::DEVICE_CHROME_OS);
 #else
   checkin->set_type(checkin_proto::DEVICE_CHROME_BROWSER);
 #endif
 
-  for (std::vector<std::string>::const_iterator iter = account_ids_.begin();
-       iter != account_ids_.end();
+  for (std::vector<std::string>::const_iterator iter =
+           request_info_.account_ids.begin();
+       iter != request_info_.account_ids.end();
        ++iter) {
     request.add_account_cookie("[" + *iter + "]");
   }
 
   std::string upload_data;
   CHECK(request.SerializeToString(&upload_data));
 
   url_fetcher_.reset(
       net::URLFetcher::Create(GURL(kCheckinURL), net::URLFetcher::POST, this));
   url_fetcher_->SetRequestContext(request_context_getter_);
@@ skipping 36 matching lines @@
   net::HttpStatusCode response_status = static_cast<net::HttpStatusCode>(
       source->GetResponseCode());
   if (response_status == net::HTTP_BAD_REQUEST ||
       response_status == net::HTTP_UNAUTHORIZED) {
     // BAD_REQUEST indicates that the request was malformed.
     // UNAUTHORIZED indicates that security token didn't match the android id.
     LOG(ERROR) << "No point retrying the checkin with status: "
                << response_status << ". Checkin failed.";
     RecordCheckinStatusToUMA(response_status == net::HTTP_BAD_REQUEST ?
         HTTP_BAD_REQUEST : HTTP_UNAUTHORIZED);
-    callback_.Run(0,0);
+    callback_.Run(response_proto);
     return;
   }
 
   if (response_status != net::HTTP_OK ||
       !source->GetResponseAsString(&response_string) ||
       !response_proto.ParseFromString(response_string)) {
     LOG(ERROR) << "Failed to get checkin response. HTTP Status: "
                << response_status << ". Retrying.";
     RecordCheckinStatusToUMA(response_status != net::HTTP_OK ?
         HTTP_NOT_OK : RESPONSE_PARSING_FAILED);
     RetryWithBackoff(true);
     return;
   }
 
   if (!response_proto.has_android_id() ||
       !response_proto.has_security_token() ||
       response_proto.android_id() == 0 ||
       response_proto.security_token() == 0) {
     LOG(ERROR) << "Android ID or security token is 0. Retrying.";
     RecordCheckinStatusToUMA(ZERO_ID_OR_TOKEN);
     RetryWithBackoff(true);
     return;
   }
 
   RecordCheckinStatusToUMA(SUCCESS);
-  callback_.Run(response_proto.android_id(), response_proto.security_token());
+  callback_.Run(response_proto);
 }
 
 }  // namespace gcm