Extension API enterprise.platformKeys.

chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.cc

Index: chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.cc
diff --git a/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.cc b/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.cc
new file mode 100644
index 0000000000000000000000000000000000000000..286d8671363ce5da8cc6dce3703cca58ff2a76d3
--- /dev/null
+++ b/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.cc
@@ -0,0 +1,162 @@
+// 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/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.h"
+
+#include "chrome/browser/extensions/api/enterprise_platform_keys/token_method.h"
+#include "chrome/common/extensions/api/enterprise_platform_keys.h"
+#include "chrome/common/extensions/api/enterprise_platform_keys_internal.h"
+
+namespace {
+const char kErrorInvalidToken[] = "Token is invalid.";
+}
+
+namespace extensions {
+
+namespace impl = enterprise_platform_keys_details;

[not at google - send to devlin, 2014/05/08 00:13:14]

this doesn't appear to be used

[pneubeck (no reviews), 2014/05/08 15:04:17]

Done.

+namespace api_epk = api::enterprise_platform_keys;
+namespace api_epki = api::enterprise_platform_keys_internal;
+
+const char kTokenIdUser[] = "user";
+
+EnterprisePlatformKeysTokenMethodExtensionFunction::
+    EnterprisePlatformKeysTokenMethodExtensionFunction() {
+}
+
+EnterprisePlatformKeysTokenMethodExtensionFunction::
+    ~EnterprisePlatformKeysTokenMethodExtensionFunction() {
+}
+
+void
+EnterprisePlatformKeysTokenMethodExtensionFunction::RespondWithoutResult() {
+  Respond(NoArguments());
+  Release();
+}
+
+void EnterprisePlatformKeysTokenMethodExtensionFunction::RespondWithResults(
+    scoped_ptr<base::ListValue> results) {
+  Respond(MultipleArguments(results.release()));
+  Release();
+}
+
+void EnterprisePlatformKeysTokenMethodExtensionFunction::RespondWithError(
+    const std::string& error_message) {
+  Respond(Error(error_message));
+  Release();
+}
+
+bool EnterprisePlatformKeysTokenMethodExtensionFunction::ValidateToken(
+    const std::string& token_id) {
+  // For now, the user token is the only valid one.
+  if (token_id != kTokenIdUser) {
+    SetError(kErrorInvalidToken);
+    return false;
+  }
+  return true;
+}
+
+EnterprisePlatformKeysInternalGenerateKeyFunction::
+    EnterprisePlatformKeysInternalGenerateKeyFunction() {
+}
+
+EnterprisePlatformKeysInternalGenerateKeyFunction::
+    ~EnterprisePlatformKeysInternalGenerateKeyFunction() {
+}
+
+ExtensionFunction::ResponseAction
+EnterprisePlatformKeysInternalGenerateKeyFunction::Run() {
+  scoped_ptr<api_epki::GenerateKey::Params> params(
+      api_epki::GenerateKey::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE_TYPESAFE(params &&
+                                       ValidateToken(params->token_id));
+  AddRef();

[not at google - send to devlin, 2014/05/08 00:13:14]

you shouldn't need to manually AddRef or Release. If you want to maintain a
reference then force CreateGenerateKey, for example, to do the AddRef/Release
itself, preferably via a scoped_refptr.

Even better like I mentioned define the interface in terms of base::Callback
which will automatically manage lifetime for you.

[pneubeck (no reviews), 2014/05/08 15:04:17]

In that case, doesn't it surprise you that the TokenMethod returned by
CreateGenerateKey is then owned by the ExtensionFunction and the
ExtensionFunction is owned by the scoped_refptr/base::Callback that is owned by
the TokenMethod?
I'm not sure that that is better.
The internal implementation (delegate) shouldn't have to care about the lifetime
of the ExtensionFunction but the other way round: The ExtensionFunction should
own the delegate. That's also why it's more common (at least from my experience)
that async Callbacks work with WeakPtrs; the owner is someone else.

And maybe the most critical: ExtensionFunctions cannot be shutdown in a
controlled way if they are owned by the callbacks. They should be owned by e.g.
ExtensionFunctionRegistry/ExtensionFunctionDispatcher.
If you agree, I could work on a solution for that (e.g. destroy the
ExtensionFunction in the next message loop cycle once a response was returned or
the JS/extension context was destroyed).

[not at google - send to devlin, 2014/05/08 15:19:32]

Where is this "delegate"? ExtensionFunction don't have owners, see comment
below.
They get shut down when they're ready to respond.
ExtensionFunction are refcounted because they typically depends on asynchronous
operations. There is a new ExtensionFunction instance created per request. The
only thing that ExtensionFunctionRegistry owns is constructors; the
ExtensionFunctionDispatcher only creates them then sets them free. Often they're
synchronous, often they're not.

+  token_method_ =
+      enterprise_platform_keys_details::CreateGenerateKey(params.Pass(), this);
+  token_method_->Run();
+  return RespondLater();
+}
+
+EnterprisePlatformKeysInternalSignFunction::
+    ~EnterprisePlatformKeysInternalSignFunction() {
+}
+
+ExtensionFunction::ResponseAction
+EnterprisePlatformKeysInternalSignFunction::Run() {
+  scoped_ptr<api_epki::Sign::Params> params(
+      api_epki::Sign::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE_TYPESAFE(params &&
+                                       ValidateToken(params->token_id));
+  AddRef();
+  token_method_ =
+      enterprise_platform_keys_details::CreateSign(params.Pass(), this);
+  token_method_->Run();
+  return RespondLater();
+}
+
+EnterprisePlatformKeysGetCertificatesFunction::
+    ~EnterprisePlatformKeysGetCertificatesFunction() {
+}
+
+ExtensionFunction::ResponseAction
+EnterprisePlatformKeysGetCertificatesFunction::Run() {
+  scoped_ptr<api_epk::GetCertificates::Params> params(
+      api_epk::GetCertificates::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE_TYPESAFE(params &&
+                                       ValidateToken(params->token_id));
+  AddRef();
+  token_method_ = enterprise_platform_keys_details::CreateGetCertificates(
+      params.Pass(), this);
+  token_method_->Run();
+  return RespondLater();
+}
+
+EnterprisePlatformKeysImportCertificateFunction::
+    ~EnterprisePlatformKeysImportCertificateFunction() {
+}
+
+ExtensionFunction::ResponseAction
+EnterprisePlatformKeysImportCertificateFunction::Run() {
+  scoped_ptr<api_epk::ImportCertificate::Params> params(
+      api_epk::ImportCertificate::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE_TYPESAFE(params &&
+                                       ValidateToken(params->token_id));
+  AddRef();
+  token_method_ = enterprise_platform_keys_details::CreateImportCertificate(
+      params.Pass(), this);
+  token_method_->Run();
+  return RespondLater();
+}
+
+EnterprisePlatformKeysRemoveCertificateFunction::
+    ~EnterprisePlatformKeysRemoveCertificateFunction() {
+}
+
+ExtensionFunction::ResponseAction
+EnterprisePlatformKeysRemoveCertificateFunction::Run() {
+  scoped_ptr<api_epk::RemoveCertificate::Params> params(
+      api_epk::RemoveCertificate::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE_TYPESAFE(params &&
+                                       ValidateToken(params->token_id));
+  AddRef();
+  token_method_ = enterprise_platform_keys_details::CreateRemoveCertificate(
+      params.Pass(), this);
+  token_method_->Run();
+  return RespondLater();
+}
+
+EnterprisePlatformKeysInternalGetTokensFunction::
+    ~EnterprisePlatformKeysInternalGetTokensFunction() {
+}
+
+ExtensionFunction::ResponseAction
+EnterprisePlatformKeysInternalGetTokensFunction::Run() {
+  EXTENSION_FUNCTION_VALIDATE_TYPESAFE(args_->empty());
+
+  std::vector<std::string> token_ids;
+  token_ids.push_back(kTokenIdUser);
+  return RespondNow(MultipleArguments(
+      api_epki::GetTokens::Results::Create(token_ids).release()));
+}
+
+}  // namespace extensions