Generate Instance ID locally.

components/gcm_driver/instance_id/instance_id_impl.cc

 // Copyright 2015 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/gcm_driver/instance_id/instance_id_impl.h"
 
+#include <algorithm>
+#include "base/base64.h"
+#include "base/bind.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop.h"
+#include "base/sha1.h"
+#include "crypto/rsa_private_key.h"
 
 namespace instance_id {
 
 // static
 InstanceID* InstanceID::Create(const std::string& app_id) {
   return new InstanceIDImpl(app_id);
 }
 
 InstanceIDImpl::InstanceIDImpl(const std::string& app_id)
     : InstanceID(app_id) {
 }
 
 InstanceIDImpl::~InstanceIDImpl() {
 }
 
 std::string InstanceIDImpl::GetID() {
-  NOTIMPLEMENTED();
-  return std::string();
+  EnsureIDGenerated();
+  return id_;
 }
 
 base::Time InstanceIDImpl::GetCreationTime() {
-  NOTIMPLEMENTED();
-  return base::Time();
+  EnsureIDGenerated();

[fgorski, 2015/04/30 22:13:12]

Are you sure we should create ID when code queries for creation time? It would
be ok to return null time, as the ID is not created and was never requested.

It also allows to query if ID was at all created.

[jianli, 2015/05/02 00:30:18]

Sounds reasonable. Changed.

+  return creation_time_;
 }
 
 void InstanceIDImpl::GetToken(
     const std::string& audience,
     const std::string& scope,
     const std::map<std::string, std::string>& options,
     const GetTokenCallback& callback) {
   NOTIMPLEMENTED();
 }
 
 void InstanceIDImpl::DeleteToken(const std::string& audience,
                                  const std::string& scope,
                                  const DeleteTokenCallback& callback) {
   NOTIMPLEMENTED();
 }
 
 void InstanceIDImpl::DeleteID(const DeleteIDCallback& callback) {
-  NOTIMPLEMENTED();
+  // TODO(jianli): Delete the key pair from the store.
+  key_pair_.reset();
+  id_.clear();
+  creation_time_ = base::Time();
+
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, this, InstanceID::SUCCESS));
+}
+
+void InstanceIDImpl::EnsureIDGenerated() {
+  if (!id_.empty())
+    return;
+
+  // Generate the public/private key pair based on random number generator if
+  // not yet.
+  if (!key_pair_) {
+    key_pair_.reset(crypto::RSAPrivateKey::Create(2048));

[fgorski, 2015/04/30 22:13:12]

const kKeyLength?

[jianli, 2015/05/02 00:30:18]

Not needed any more.

+    if (!key_pair_) {
+      DVLOG(1) << "Cannot generate key pair.";
+      return;
+    }
+
+    // Record the time.
+    creation_time_ = base::Time::Now();
+
+    // TODO(jianli): Store the key pair.
+  }
+
+  // Now produce the ID based on the public key of the key pair.
+
+  // 1) Computes the SHA1 of public key of the key pair.
+  std::vector<uint8> public_key;
+  if (!key_pair_->ExportPublicKey(&public_key)) {
+    DVLOG(1) << "Cannot export public key.";
+    return;
+  }
+
+  uint8 digest[base::kSHA1Length];
+  base::SHA1HashBytes(public_key.data(), public_key.size(), digest);
+
+  // 2) Transforms the first 4 bits of the SHA1 value to 0x9.
+  uint8 d0 = digest[0];
+  d0 = 0x90 + (0xF & d0);
+  digest[0] = d0 & 0xFF;
+
+  // 3) Truncates the transformed SHA1 value to 8 bytes and encode it in in
+  //    Android-compatible base64 scheme:

[fgorski, 2015/04/30 22:13:12]

move below as point 4

[jianli, 2015/05/02 00:30:17]

Not needed any more.

+  //    * URL safe: '/' replaced by '_' and '+' replaced by '-'.
+  //    * No padding: any trailing '=' will be removed.
+  base::Base64Encode(
+      base::StringPiece(reinterpret_cast<const char*>(digest), 8),
+      &id_);
+  std::replace(id_.begin(), id_.end(), '+', '-');
+  std::replace(id_.begin(), id_.end(), '/', '_');
+  id_.erase(std::remove(id_.begin(), id_.end(), '='), id_.end());
 }
 
 }  // namespace instance_id