PaymentApp: Factor out functions to serialize/deserialize manifest data.

content/browser/payments/payment_app_manager_unittest.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 <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 49 matching lines @@
         embedded_worker_helper_(new EmbeddedWorkerTestHelper(base::FilePath())),
         storage_partition_impl_(new StoragePartitionImpl(
             embedded_worker_helper_->browser_context(), base::FilePath(),
             nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
             nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
 
     embedded_worker_helper_->context_wrapper()->set_storage_partition(
         storage_partition_impl_.get());
 
     payment_app_context_ =
-        new PaymentAppContext(embedded_worker_helper_->context_wrapper());
+        new PaymentAppContextImpl(embedded_worker_helper_->context_wrapper());
 
     bool called = false;
     embedded_worker_helper_->context()->RegisterServiceWorker(
         GURL(kServiceWorkerPattern), GURL(kServiceWorkerScript), NULL,
         base::Bind(&RegisterServiceWorkerCallback, &called,
                    &sw_registration_id_));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(called);
 
     mojo::InterfaceRequest<payments::mojom::PaymentAppManager> request =
@@ skipping 16 matching lines @@
     manager_->SetManifest(scope, std::move(manifest), callback);
     base::RunLoop().RunUntilIdle();
   }
 
   void GetManifest(const std::string& scope,
                    const PaymentAppManager::GetManifestCallback& callback) {
     manager_->GetManifest(scope, callback);
     base::RunLoop().RunUntilIdle();
   }
 
+  void GetAll() {
+    payment_app_context_->GetAllManifests(base::Bind(&DidGetAll));
+    base::RunLoop().RunUntilIdle();
+  }
+
+  static void DidGetAll(const std::vector<PaymentAppContext::PaymentAppManifestWithID>& manifests) {
+    LOG(INFO) << "zino";
+  }
+
  private:
   std::unique_ptr<TestBrowserThreadBundle> thread_bundle_;
   std::unique_ptr<EmbeddedWorkerTestHelper> embedded_worker_helper_;
   std::unique_ptr<StoragePartitionImpl> storage_partition_impl_;
   int64_t sw_registration_id_;
-  scoped_refptr<PaymentAppContext> payment_app_context_;
+  scoped_refptr<PaymentAppContextImpl> payment_app_context_;
   payments::mojom::PaymentAppManagerPtr service_;
 
   // Owned by payment_app_context_.
   PaymentAppManager* manager_;
 
   DISALLOW_COPY_AND_ASSIGN(PaymentAppManagerTest);
 };
 
 TEST_F(PaymentAppManagerTest, SetAndGetManifest) {
   payments::mojom::PaymentAppOptionPtr option =
@@ skipping 34 matching lines @@
 TEST_F(PaymentAppManagerTest, GetManifestWithoutAssociatedServiceWorker) {
   payments::mojom::PaymentAppManifestPtr read_manifest;
   payments::mojom::PaymentAppManifestError read_error;
   GetManifest(kServiceWorkerPattern,
               base::Bind(&GetManifestCallback, &read_manifest, &read_error));
 
   EXPECT_EQ(read_error, payments::mojom::PaymentAppManifestError::
                             MANIFEST_STORAGE_OPERATION_FAILED);
 }
 
+TEST_F(PaymentAppManagerTest, Test) {
+  payments::mojom::PaymentAppOptionPtr option =
+      payments::mojom::PaymentAppOption::New();
+  option->label = "Visa ****";
+  option->id = "payment-app-id";
+  option->icon = std::string("payment-app-icon");
+  option->enabled_methods.push_back("visa");
+
+  payments::mojom::PaymentAppManifestPtr manifest =
+      payments::mojom::PaymentAppManifest::New();
+  manifest->icon = std::string("payment-app-icon");
+  manifest->label = "Payment App";
+  manifest->options.push_back(std::move(option));
+
+  payments::mojom::PaymentAppManifestError error;
+  SetManifest(kServiceWorkerPattern, std::move(manifest),
+              base::Bind(&SetManifestCallback, &error));
+
+  ASSERT_EQ(error, payments::mojom::PaymentAppManifestError::NONE);
+
+  GetAll();
+}
+
 }  // namespace content