The chrome.lockScreen.data API implementation

extensions/browser/api/lock_screen_data/lock_screen_data_api.cc

 // Copyright 2017 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 "extensions/browser/api/lock_screen_data/lock_screen_data_api.h"
 
-#include <memory>
+#include <string>
+#include <utility>
 #include <vector>
 
+#include "extensions/browser/api/lock_screen_data/data_item.h"
+#include "extensions/browser/api/lock_screen_data/item_storage.h"
+#include "extensions/browser/api/lock_screen_data/operation_result.h"
 #include "extensions/common/api/lock_screen_data.h"
 
 namespace extensions {
 
+namespace {
+
+std::string GetErrorString(lock_screen_data::OperationResult result) {
+  switch (result) {
+    case lock_screen_data::OperationResult::kSuccess:
+      NOTREACHED() << "Expected a failure code.";
+      return "Unknown";
+    case lock_screen_data::OperationResult::kFailed:
+      return "Unknown";
+    case lock_screen_data::OperationResult::kInvalidKey:
+    case lock_screen_data::OperationResult::kWrongKey:
+      return "Internal - encryption";
+    case lock_screen_data::OperationResult::kAlreadyRegistered:
+      return "Duplicate item";
+    case lock_screen_data::OperationResult::kNotFound:
+    case lock_screen_data::OperationResult::kUnknownExtension:
+      return "Not found";
+  }
+  NOTREACHED() << "Unknown operation status";
+  return "Unknown";
+}
+
+}  // namespace
+
 LockScreenDataCreateFunction::LockScreenDataCreateFunction() {}
 
 LockScreenDataCreateFunction::~LockScreenDataCreateFunction() {}
 
 ExtensionFunction::ResponseAction LockScreenDataCreateFunction::Run() {
+  if (!lock_screen_data::ItemStorage::Get(browser_context()))
+    return RespondNow(Error("Not available"));

[rkc, 2017/07/10 20:04:00]

This should never happen right? If so, then put in a LOG(ERROR) here to document
that this happened. It might be an indication of something gone pretty wrong.

I would argue for a FATAL() but crashing the lockscreen seems worse.

Same in other functions.

[tbarzic, 2017/07/10 22:29:48]

For create, it should not happen (as this one is only available in lock screen
context), but for the rest, the app could call the function from a profile that
does not have access to the storage - e.g. from secondary use profile (in
multi-profile environment).

+
+  lock_screen_data::ItemStorage::Get(browser_context())
+      ->CreateItem(extension_id(),
+                   base::Bind(&LockScreenDataCreateFunction::OnDone, this));
+  return RespondLater();
+}
+
+void LockScreenDataCreateFunction::OnDone(
+    lock_screen_data::OperationResult result,
+    const lock_screen_data::DataItem* item) {
+  if (result != lock_screen_data::OperationResult::kSuccess) {
+    Respond(Error(GetErrorString(result)));
+    return;
+  }
+
   api::lock_screen_data::DataItemInfo item_info;
-  item_info.id = "fake";
-  return RespondNow(
+  item_info.id = item->id();
+  Respond(
       ArgumentList(api::lock_screen_data::Create::Results::Create(item_info)));
 }
 
 LockScreenDataGetAllFunction::LockScreenDataGetAllFunction() {}
 
 LockScreenDataGetAllFunction::~LockScreenDataGetAllFunction() {}
 
 ExtensionFunction::ResponseAction LockScreenDataGetAllFunction::Run() {
+  if (!lock_screen_data::ItemStorage::Get(browser_context()))
+    return RespondNow(Error("Not available"));
+
+  lock_screen_data::ItemStorage::Get(browser_context())
+      ->GetAllForExtension(
+          extension_id(),
+          base::Bind(&LockScreenDataGetAllFunction::OnDone, this));
+  return RespondLater();
+}
+
+void LockScreenDataGetAllFunction::OnDone(
+    const std::vector<const lock_screen_data::DataItem*>& items) {
   std::vector<api::lock_screen_data::DataItemInfo> items_info;
-  return RespondNow(
+  for (auto* const item : items) {
+    if (!item)
+      continue;
+    api::lock_screen_data::DataItemInfo item_info;
+    item_info.id = item->id();
+    items_info.emplace_back(std::move(item_info));
+  }
+
+  Respond(
       ArgumentList(api::lock_screen_data::GetAll::Results::Create(items_info)));
 }
 
 LockScreenDataGetContentFunction::LockScreenDataGetContentFunction() {}
 
 LockScreenDataGetContentFunction::~LockScreenDataGetContentFunction() {}
 
 ExtensionFunction::ResponseAction LockScreenDataGetContentFunction::Run() {
+  if (!lock_screen_data::ItemStorage::Get(browser_context()))
+    return RespondNow(Error("Not available"));
+
   std::unique_ptr<api::lock_screen_data::GetContent::Params> params(
       api::lock_screen_data::GetContent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  return RespondNow(Error("Not found"));
+  lock_screen_data::ItemStorage::Get(browser_context())
+      ->GetItemContent(
+          extension_id(), params->id,
+          base::Bind(&LockScreenDataGetContentFunction::OnDone, this));
+  return RespondLater();
+}
+
+void LockScreenDataGetContentFunction::OnDone(
+    lock_screen_data::OperationResult result,
+    std::unique_ptr<std::vector<char>> data) {
+  if (result == lock_screen_data::OperationResult::kSuccess) {
+    Respond(ArgumentList(
+        api::lock_screen_data::GetContent::Results::Create(*data)));
+    return;
+  }
+  Respond(Error(GetErrorString(result)));
 }
 
 LockScreenDataSetContentFunction::LockScreenDataSetContentFunction() {}
 
 LockScreenDataSetContentFunction::~LockScreenDataSetContentFunction() {}
 
 ExtensionFunction::ResponseAction LockScreenDataSetContentFunction::Run() {
+  if (!lock_screen_data::ItemStorage::Get(browser_context()))
+    return RespondNow(Error("Not available"));
+
   std::unique_ptr<api::lock_screen_data::SetContent::Params> params(
       api::lock_screen_data::SetContent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  return RespondNow(Error("Not found"));
+  lock_screen_data::ItemStorage::Get(browser_context())
+      ->SetItemContent(
+          extension_id(), params->id, params->data,
+          base::Bind(&LockScreenDataSetContentFunction::OnDone, this));
+  return RespondLater();
+}
+
+void LockScreenDataSetContentFunction::OnDone(
+    lock_screen_data::OperationResult result) {
+  if (result == lock_screen_data::OperationResult::kSuccess) {
+    Respond(NoArguments());
+    return;
+  }
+  Respond(Error(GetErrorString(result)));
 }
 
 LockScreenDataDeleteFunction::LockScreenDataDeleteFunction() {}
 
 LockScreenDataDeleteFunction::~LockScreenDataDeleteFunction() {}
 
 ExtensionFunction::ResponseAction LockScreenDataDeleteFunction::Run() {
   std::unique_ptr<api::lock_screen_data::Delete::Params> params(
       api::lock_screen_data::Delete::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  return RespondNow(Error("Not found."));
+
+  lock_screen_data::ItemStorage::Get(browser_context())
+      ->DeleteItem(extension_id(), params->id,
+                   base::Bind(&LockScreenDataDeleteFunction::OnDone, this));
+  return RespondLater();
+}
+
+void LockScreenDataDeleteFunction::OnDone(
+    lock_screen_data::OperationResult result) {
+  if (result == lock_screen_data::OperationResult::kSuccess) {
+    Respond(NoArguments());
+    return;
+  }
+  Respond(Error(GetErrorString(result)));
 }
 
 }  // namespace extensions