Small clean up in PlatformKeysService.

chrome/browser/chromeos/platform_keys/platform_keys_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_PLATFORM_KEYS_SERVICE_H_
 #define CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_PLATFORM_KEYS_SERVICE_H_
 
 #include <string>
 
 #include "base/callback_forward.h"
@@ skipping 67 matching lines @@
   // only.
   // Will only call back during the lifetime of this object.
   void 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);
 
  private:
-  typedef base::Callback<void(scoped_ptr<base::ListValue> platform_keys)>
-      GetPlatformKeysCallback;
+  using GetPlatformKeysCallback =
+      base::Callback<void(scoped_ptr<base::ListValue> platform_keys)>;
 
   // Registers the given public key as newly generated key, which is allowed to
   // be used for signing for a single time. Afterwards, calls |callback|. If
   // registration was successful, passes |true| otherwise |false| to the
   // callback.
   void RegisterPublicKey(const std::string& extension_id,
                          const std::string& public_key_spki_der,
-                         const base::Callback<void(bool)>& callback);
+                         const base::Closure& callback);
 
   // Gets the current validity of the given public key by reading StateStore.
   // Invalidates the key if it was found to be valid. Finally, calls |callback|
   // with the old validity.
   void ReadValidityAndInvalidateKey(const std::string& extension_id,
                                     const std::string& public_key_spki_der,
                                     const base::Callback<void(bool)>& callback);
 
   // Reads the list of public keys currently registered for |extension_id| from
   // StateStore. Calls |callback| with the read list, or a new empty list if
   // none existed. If an error occurred, calls |callback| with NULL.
   void GetPlatformKeysOfExtension(const std::string& extension_id,
                                   const GetPlatformKeysCallback& callback);
 
+  // Writes |platform_keys| to the state store of the extension with id
+  // |extension_id|.
+  void SetPlatformKeysOfExtension(const std::string& extension_id,
+                                  scoped_ptr<base::ListValue> platform_keys);
+
   // Callback used by |GenerateRSAKey|.
   // If the key generation was successful, registers the generated public key
   // for the given extension. If any error occurs during key generation or
   // registration, calls |callback| with an error. Otherwise, on success, calls
   // |callback| with the public key.
   void GenerateRSAKeyCallback(const std::string& extension_id,
                               const GenerateKeyCallback& callback,
                               const std::string& public_key_spki_der,
                               const std::string& error_message);
 
   // Callback used by |RegisterPublicKey|.
   // Updates the old |platform_keys| read from the StateStore and writes the
   // updated value back to the StateStore.
   void RegisterPublicKeyGotPlatformKeys(
       const std::string& extension_id,
       const std::string& public_key_spki_der,
-      const base::Callback<void(bool)>& callback,
+      const base::Closure& callback,
       scoped_ptr<base::ListValue> platform_keys);
 
   // Callback used by |ReadValidityAndInvalidateKey|.
   // Invalidates the given public key so that future signing is prohibited and
   // calls |callback| with the old validity.
   void InvalidateKey(const std::string& extension_id,
                      const std::string& public_key_spki_der,
                      const base::Callback<void(bool)>& callback,
                      scoped_ptr<base::ListValue> platform_keys);
 
   // Callback used by |GetPlatformKeysOfExtension|.
   // Is called with |value| set to the PlatformKeys value read from the
   // StateStore, which it forwards to |callback|. On error, calls |callback|
   // with NULL; if no value existed, with an empty list.
   void GotPlatformKeysOfExtension(const std::string& extension_id,
                                   const GetPlatformKeysCallback& callback,
                                   scoped_ptr<base::Value> value);
 
   content::BrowserContext* browser_context_;
   extensions::StateStore* state_store_;
   base::WeakPtrFactory<PlatformKeysService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformKeysService);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_PLATFORM_KEYS_SERVICE_H_