DevTools: add about:flag for ADB-less remote debugging.

chrome/browser/devtools/adb/android_rsa.cc

-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 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/devtools/adb/android_rsa.h"
 
 #include "base/base64.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
@@ skipping 177 matching lines @@
   if (pq)
     *pq = q;
   else
     BnFree(q);
   if (pr)
     *pr = ca;
   else
     BnFree(ca);
 }
 
-crypto::RSAPrivateKey* GetOrCreatePrivateKey(Profile* profile) {
+}  // namespace
+
+crypto::RSAPrivateKey* AndroidRSAPrivateKey(Profile* profile) {
   std::string encoded_key =
       profile->GetPrefs()->GetString(prefs::kDevToolsAdbKey);
   std::string decoded_key;
   scoped_ptr<crypto::RSAPrivateKey> key;
   if (!encoded_key.empty() && base::Base64Decode(encoded_key, &decoded_key)) {
     std::vector<uint8> key_info(decoded_key.begin(), decoded_key.end());
     key.reset(crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info));
   }
   if (!key) {
     key.reset(crypto::RSAPrivateKey::Create(2048));
     std::vector<uint8> key_info;
     if (!key || !key->ExportPrivateKey(&key_info))
       return NULL;
 
     std::string key_string(key_info.begin(), key_info.end());
     if (base::Base64Encode(key_string, &encoded_key)) {
       profile->GetPrefs()->SetString(prefs::kDevToolsAdbKey,
                                      encoded_key);
     }
   }
   return key.release();
 }
 
-}  // namespace
-
-std::string AndroidRSAPublicKey(Profile* profile) {
-  scoped_ptr<crypto::RSAPrivateKey> key(GetOrCreatePrivateKey(profile));
+std::string AndroidRSAPublicKey(crypto::RSAPrivateKey* key) {
+  std::vector<uint8> public_key;
   if (!key)
     return kDummyRSAPublicKey;
 
-  std::vector<uint8> public_key;
   key->ExportPublicKey(&public_key);
   std::string asn1(public_key.begin(), public_key.end());
 
   base::StringPiece pk;
   if (!net::asn1::ExtractSubjectPublicKeyFromSPKI(asn1, &pk))
     return kDummyRSAPublicKey;
 
   // Skip 10 byte asn1 prefix to the modulus.
   std::vector<uint8> pk_data(pk.data() + 10, pk.data() + pk.length());
   uint32* n = BnNew();
@@ skipping 30 matching lines @@
   BnFree(n);
   BnFree(r);
   BnFree(rr);
 
   std::string output;
   std::string input(reinterpret_cast<char*>(&pkey), sizeof(pkey));
   base::Base64Encode(input, &output);
   return output;
 }
 
-std::string AndroidRSASign(Profile* profile, const std::string& body) {
-  scoped_ptr<crypto::RSAPrivateKey> key(GetOrCreatePrivateKey(profile));
-  if (!key)
-    return std::string();
-
+std::string AndroidRSASign(crypto::RSAPrivateKey* key,
+                           const std::string& body) {
   std::vector<uint8> digest(body.begin(), body.end());
   std::vector<uint8> result;
-  if (!crypto::SignatureCreator::Sign(key.get(), vector_as_array(&digest),
+  if (!crypto::SignatureCreator::Sign(key, vector_as_array(&digest),
                                       digest.size(), &result)) {
     return std::string();
   }
   return std::string(result.begin(), result.end());
 }