Build correct URL for cacheinvalidation endpoint.

sync/notifier/gcm_network_channel.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 "base/base64.h"
+#include "google/cacheinvalidation/android_channel.pb.h"
+#include "google/cacheinvalidation/channel_common.pb.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 #include "sync/notifier/gcm_network_channel.h"
 #include "sync/notifier/gcm_network_channel_delegate.h"
 
 namespace syncer {
 
 namespace {
 
+const char kCacheInvalidationEndpointUrl[] =
+    "https://clients4.google.com/invalidation/android/request/";
+const char kCacheInvalidationPackageName[] = "com.google.chrome.invalidations";
+
 // Register backoff policy.
 const net::BackoffEntry::Policy kRegisterBackoffPolicy = {
   // Number of initial errors (in sequence) to ignore before applying
   // exponential back-off rules.
   0,
 
   // Initial delay for exponential back-off in ms.
   2000, // 2 seconds.
 
   // Factor by which the waiting time will be multiplied.
@@ skipping 109 matching lines @@
     // token service. Just drop this request, cacheinvalidations will retry
     // sending message and at that time we'll retry requesting access token.
     DVLOG(1) << "RequestAccessToken failed: " << error.ToString();
     return;
   }
   DCHECK(!token.empty());
   // Save access token in case POST fails and we need to invalidate it.
   access_token_ = token;
 
   DVLOG(2) << "Got access token, sending message";
-
-  fetcher_.reset(net::URLFetcher::Create(BuildUrl(), net::URLFetcher::POST,
-                                         this));
+  fetcher_.reset(net::URLFetcher::Create(
+      BuildUrl(registration_id_), net::URLFetcher::POST, this));
   fetcher_->SetRequestContext(request_context_getter_);
   const std::string auth_header("Authorization: Bearer " + access_token_);
   fetcher_->AddExtraRequestHeader(auth_header);
   fetcher_->SetUploadData("application/x-protobuffer", encoded_message_);
   fetcher_->Start();
   // Clear message to prevent accidentally resending it in the future.
   encoded_message_.clear();
 }
 
 void GCMNetworkChannel::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(fetcher_, source);
   // Free fetcher at the end of function.
   scoped_ptr<net::URLFetcher> fetcher = fetcher_.Pass();
 
   net::URLRequestStatus status = fetcher->GetStatus();
   if (!status.is_success()) {
     DVLOG(1) << "URLFetcher failure";
     return;
   }
 
   if (fetcher->GetResponseCode() == net::HTTP_UNAUTHORIZED) {
     DVLOG(1) << "URLFetcher failure: HTTP_UNAUTHORIZED";
     delegate_->InvalidateToken(access_token_);
     return;
   }
   DVLOG(2) << "URLFetcher success";
 }
 
-GURL GCMNetworkChannel::BuildUrl() {
-  DCHECK(!registration_id_.empty());
-  // Prepare NetworkEndpointId using registration_id
-  // Serialize NetworkEndpointId into byte array and base64 encode.
-  // Format url using encoded NetworkEndpointId.
-  // TODO(pavely): implement all of the above.
-  return GURL("http://invalid.url.com");
+GURL GCMNetworkChannel::BuildUrl(const std::string& registration_id) {
+  DCHECK(!registration_id.empty());
+  std::string buffer;
+
+  ipc::invalidation::EndpointId endpoint_id;
+  endpoint_id.set_c2dm_registration_id(registration_id);
+  endpoint_id.set_client_key(std::string());
+  endpoint_id.set_package_name(kCacheInvalidationPackageName);
+  endpoint_id.mutable_channel_version()->set_major_version(
+      ipc::invalidation::INITIAL);
+  endpoint_id.SerializeToString(&buffer);
+
+  ipc::invalidation::NetworkEndpointId network_endpoint_id;
+  network_endpoint_id.set_network_address(
+      ipc::invalidation::NetworkEndpointId_NetworkAddress_ANDROID);
+  network_endpoint_id.set_client_address(buffer);

[rlarocque, 2014/02/26 22:55:46]

Couldn't you get the same serialized result by making the client_address an
embedded message protobuf of type EndpointId?

I'm guessing these are not your protos, so there's not much you could do to
change it.  I'm curious to know if there's any justification for it.

[pavely, 2014/02/26 23:11:13]

If network_address is not NetworkAddress::ANDROID then client_address will have
different protobuf serialized into it. It is the way how server decodes address.

+  network_endpoint_id.SerializeToString(&buffer);

[rlarocque, 2014/02/26 22:55:46]

I'd prefer to see a different buffer for this serialization.  As it is, it's
hard to tell whether or not this overwrite is intentional.

[pavely, 2014/02/26 23:11:13]

Done.

+
+  std::string base64URLPiece;
+  base::Base64Encode(buffer, &base64URLPiece);
+
+  std::string url(kCacheInvalidationEndpointUrl);
+  url += base64URLPiece;
+  return GURL(url);
 }
 
 }  // namespace syncer