pac

content/browser/payments/payment_app_database.cc

 // Copyright 2016 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 "content/browser/payments/payment_app_manager.h"
+#include "content/browser/payments/payment_app_database.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/optional.h"
 #include "content/browser/payments/payment_app.pb.h"
-#include "content/browser/payments/payment_app_context.h"
+#include "content/browser/payments/payment_app_context_impl.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 namespace {
 
 const char kPaymentAppManifestDataKey[] = "PaymentAppManifestData";
 
 }  // namespace
 
-PaymentAppManager::~PaymentAppManager() {
+PaymentAppDatabase::PaymentAppDatabase(
+    scoped_refptr<ServiceWorkerContextWrapper> service_worker_context)
+    : service_worker_context_(service_worker_context), weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
-PaymentAppManager::PaymentAppManager(
-    PaymentAppContext* payment_app_context,
-    mojo::InterfaceRequest<payments::mojom::PaymentAppManager> request)
-    : payment_app_context_(payment_app_context),
-      binding_(this, std::move(request)),
-      weak_ptr_factory_(this) {
+PaymentAppDatabase::~PaymentAppDatabase() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(payment_app_context);
-
-  binding_.set_connection_error_handler(
-      base::Bind(&PaymentAppManager::OnConnectionError,
-                 base::Unretained(this)));
 }
 
-void PaymentAppManager::OnConnectionError() {
-  payment_app_context_->ServiceHadConnectionError(this);
+void PaymentAppDatabase::WriteManifest(
+    const GURL& scope,
+    payments::mojom::PaymentAppManifestPtr manifest,
+    const WriteManifestCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  service_worker_context_->FindReadyRegistrationForPattern(
+      scope, base::Bind(&PaymentAppDatabase::DidFindRegistrationToWriteManifest,
+                        weak_ptr_factory_.GetWeakPtr(),
+                        base::Passed(std::move(manifest)), callback));
 }
 
-void PaymentAppManager::SetManifest(
-    const std::string& scope,
-    payments::mojom::PaymentAppManifestPtr manifest,
-    const SetManifestCallback& callback) {
+void PaymentAppDatabase::ReadManifest(const GURL& scope,
+                                      const ReadManifestCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  // TODO(zino): Should implement requesting a permission for users to allow
-  // the payment app to be registered. Please see http://crbug.com/665949.
-
-  payment_app_context_->service_worker_context()
-      ->FindReadyRegistrationForPattern(
-          GURL(scope),
-          base::Bind(&PaymentAppManager::DidFindRegistrationToSetManifest,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(std::move(manifest)), callback));
+  service_worker_context_->FindReadyRegistrationForPattern(
+      scope, base::Bind(&PaymentAppDatabase::DidFindRegistrationToReadManifest,
+                        weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
-void PaymentAppManager::GetManifest(const std::string& scope,
-                                    const GetManifestCallback& callback) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  payment_app_context_->service_worker_context()
-      ->FindReadyRegistrationForPattern(
-          GURL(scope),
-          base::Bind(&PaymentAppManager::DidFindRegistrationToGetManifest,
-                     weak_ptr_factory_.GetWeakPtr(), callback));
-}
-
-void PaymentAppManager::DidFindRegistrationToSetManifest(
+void PaymentAppDatabase::DidFindRegistrationToWriteManifest(
     payments::mojom::PaymentAppManifestPtr manifest,
-    const SetManifestCallback& callback,
+    const WriteManifestCallback& callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK) {
     callback.Run(payments::mojom::PaymentAppManifestError::NO_ACTIVE_WORKER);
     return;
   }
 
   PaymentAppManifestProto manifest_proto;
   manifest_proto.set_name(manifest->name);
   if (manifest->icon)
     manifest_proto.set_icon(manifest->icon.value());
 
   for (const auto& option : manifest->options) {
     PaymentAppOptionProto* option_proto = manifest_proto.add_options();
     option_proto->set_name(option->name);
     if (option->icon)
       option_proto->set_icon(option->icon.value());
     option_proto->set_id(option->id);
     for (const auto& method : option->enabled_methods) {
       option_proto->add_enabled_methods(method);
     }
   }
 
   std::string serialized;
   bool success = manifest_proto.SerializeToString(&serialized);
   DCHECK(success);
 
-  payment_app_context_->service_worker_context()->StoreRegistrationUserData(
+  service_worker_context_->StoreRegistrationUserData(
       registration->id(), registration->pattern().GetOrigin(),
       {{kPaymentAppManifestDataKey, serialized}},
-      base::Bind(&PaymentAppManager::DidSetManifest,
+      base::Bind(&PaymentAppDatabase::DidWriteManifest,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
-void PaymentAppManager::DidSetManifest(const SetManifestCallback& callback,
-                                       ServiceWorkerStatusCode status) {
+void PaymentAppDatabase::DidWriteManifest(const WriteManifestCallback& callback,
+                                          ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return callback.Run(status == SERVICE_WORKER_OK
                           ? payments::mojom::PaymentAppManifestError::NONE
                           : payments::mojom::PaymentAppManifestError::
                                 MANIFEST_STORAGE_OPERATION_FAILED);
 }
 
-void PaymentAppManager::DidFindRegistrationToGetManifest(
-    const GetManifestCallback& callback,
+void PaymentAppDatabase::DidFindRegistrationToReadManifest(
+    const ReadManifestCallback& callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK) {
     callback.Run(payments::mojom::PaymentAppManifest::New(),
                  payments::mojom::PaymentAppManifestError::NO_ACTIVE_WORKER);
     return;
   }
 
-  payment_app_context_->service_worker_context()->GetRegistrationUserData(
+  service_worker_context_->GetRegistrationUserData(
       registration->id(), {kPaymentAppManifestDataKey},
-      base::Bind(&PaymentAppManager::DidGetManifest,
+      base::Bind(&PaymentAppDatabase::DidReadManifest,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
-void PaymentAppManager::DidGetManifest(const GetManifestCallback& callback,
-                                       const std::vector<std::string>& data,
-                                       ServiceWorkerStatusCode status) {
+void PaymentAppDatabase::DidReadManifest(const ReadManifestCallback& callback,
+                                         const std::vector<std::string>& data,
+                                         ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK || data.size() != 1) {
     callback.Run(payments::mojom::PaymentAppManifest::New(),
                  payments::mojom::PaymentAppManifestError::
                      MANIFEST_STORAGE_OPERATION_FAILED);
     return;
   }
 
   PaymentAppManifestProto manifest_proto;
   bool success = manifest_proto.ParseFromString(data[0]);
@@ skipping 19 matching lines @@
     for (const auto& method : option_proto.enabled_methods())
       option->enabled_methods.push_back(method);
     manifest->options.push_back(std::move(option));
   }
 
   callback.Run(std::move(manifest),
                payments::mojom::PaymentAppManifestError::NONE);
 }
 
 }  // namespace content