enterprise.platformKeys: Respect the 'hash' argument of generateKey.

chrome/browser/chromeos/platform_keys/platform_keys_service.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 "chrome/browser/chromeos/platform_keys/platform_keys_service.h"
 
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys.h"
@@ skipping 31 matching lines @@
     callback.Run(std::string() /* no public key */, kErrorInternal);
 }
 
 // Callback used by |PlatformKeysService::Sign|.
 // Is called with the old validity of |public_key_spki_der| (or false if an
 // error occurred during reading the StateStore). If allowed, starts the actual
 // signing operation which will call back |callback|. If not allowed, calls
 // |callback| with an error.
 void CheckValidityAndSign(const std::string& token_id,
                           const std::string& public_key_spki_der,
+                          platform_keys::HashAlgorithm hash_algorithm,
                           const std::string& data,
                           const PlatformKeysService::SignCallback& callback,
                           content::BrowserContext* browser_context,
                           bool key_is_valid) {
   if (!key_is_valid) {
     callback.Run(std::string() /* no signature */,
                  kErrorKeyNotAllowedForSigning);
     return;
   }
-  platform_keys::subtle::Sign(
-      token_id, public_key_spki_der, data, callback, browser_context);
+  platform_keys::subtle::Sign(token_id,
+                              public_key_spki_der,
+                              hash_algorithm,
+                              data,
+                              callback,
+                              browser_context);
 }
 
 }  // namespace
 
 PlatformKeysService::PlatformKeysService(
     content::BrowserContext* browser_context,
     extensions::StateStore* state_store)
     : browser_context_(browser_context),
       state_store_(state_store),
       weak_factory_(this) {
@@ skipping 14 matching lines @@
       modulus_length,
       base::Bind(&PlatformKeysService::GenerateRSAKeyCallback,
                  weak_factory_.GetWeakPtr(),
                  extension_id,
                  callback),
       browser_context_);
 }
 
 void PlatformKeysService::Sign(const std::string& token_id,
                                const std::string& public_key_spki_der,
+                               platform_keys::HashAlgorithm hash_algorithm,
                                const std::string& data,
                                const std::string& extension_id,
                                const SignCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ReadValidityAndInvalidateKey(extension_id,
                                public_key_spki_der,
                                base::Bind(&CheckValidityAndSign,
                                           token_id,
                                           public_key_spki_der,
+                                          hash_algorithm,
                                           data,
                                           callback,
                                           browser_context_));
 }
 
 void PlatformKeysService::RegisterPublicKey(
     const std::string& extension_id,
     const std::string& public_key_spki_der,
     const base::Callback<void(bool)>& callback) {
   GetPlatformKeysOfExtension(
@@ skipping 99 matching lines @@
   base::ListValue* keys = NULL;
   if (!value->GetAsList(&keys)) {
     LOG(ERROR) << "Found a value of wrong type.";
     value.reset();
   }
   ignore_result(value.release());
   callback.Run(make_scoped_ptr(keys));
 }
 
 }  // namespace chromeos