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:
+    case lock_screen_data::OperationResult::kPending:
+      NOTREACHED() << "Expected a failure code.";
+      return "Unknown";
+    case lock_screen_data::OperationResult::kFailed:
+      return "Unknown";
+    case lock_screen_data::OperationResult::kFileCreationFailed:
+    case lock_screen_data::OperationResult::kFileWriteFailed:
+    case lock_screen_data::OperationResult::kFileReadFailed:
+    case lock_screen_data::OperationResult::kFileDeleteFailed:
+      return "Internal - file operation";
+    case lock_screen_data::OperationResult::kInvalidKey:
+    case lock_screen_data::OperationResult::kWrongKey:
+      return "Internal - encryption";
+    case lock_screen_data::OperationResult::kNotFound:
+      return "Not found";
+    case lock_screen_data::OperationResult::kNoBackingFile:
+      return "Not initialized";
+  }
+  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"));
+
+  const lock_screen_data::DataItem* item =
+      lock_screen_data::ItemStorage::Get(browser_context())
+          ->CreateItem(extension_id());
+  if (!item)
+    return RespondNow(Error("Creation failed"));
+
   api::lock_screen_data::DataItemInfo item_info;
-  item_info.id = "fake";
+  item_info.id = item->id();
   return RespondNow(
       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"));
+
+  std::vector<const lock_screen_data::DataItem*> items =
+      lock_screen_data::ItemStorage::Get(browser_context())
+          ->GetAllForExtension(extension_id());
+
   std::vector<api::lock_screen_data::DataItemInfo> items_info;
+  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));
+  }
+
   return RespondNow(
       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::OperationResult result =
+      lock_screen_data::ItemStorage::Get(browser_context())
+          ->GetItemContent(
+              extension_id(), params->id,
+              base::Bind(&LockScreenDataGetContentFunction::OnDone, this));
+  if (result == lock_screen_data::OperationResult::kPending)
+    return RespondLater();
+  if (result == lock_screen_data::OperationResult::kNoBackingFile) {
+    return RespondNow(
+        ArgumentList(api::lock_screen_data::GetContent::Results::Create(
+            std::vector<char>())));
+  }
+  return RespondNow(Error(GetErrorString(result)));
+}
+
+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::OperationResult result =
+      lock_screen_data::ItemStorage::Get(browser_context())
+          ->SetItemContent(
+              extension_id(), params->id, params->data,
+              base::Bind(&LockScreenDataSetContentFunction::OnDone, this));
+  if (result == lock_screen_data::OperationResult::kPending)
+    return RespondLater();
+  return RespondNow(Error(GetErrorString(result)));
+}
+
+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::OperationResult result =
+      lock_screen_data::ItemStorage::Get(browser_context())
+          ->DeleteItem(extension_id(), params->id);
+  if (result == lock_screen_data::OperationResult::kSuccess)
+    return RespondNow(NoArguments());
+  return RespondNow(Error(GetErrorString(result)));
 }
 
 }  // namespace extensions