PaymentHandler: Add a key prefix to avoid key conflicts with others.

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_database.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/optional.h"
+#include "base/strings/stringprintf.h"
 #include "content/browser/payments/payment_app.pb.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 {
 
 using ::payments::mojom::PaymentHandlerStatus;
 using ::payments::mojom::PaymentInstrument;
 using ::payments::mojom::PaymentInstrumentPtr;
 
 const char kPaymentAppManifestDataKey[] = "PaymentAppManifestData";
+const char kPaymentInstrumentKeyPrefix[] = "PaymentInstrument:";
+
+std::string CreatePaymentInstrumentKey(const std::string& instrument_key) {
+  return base::StringPrintf("%s%s", kPaymentInstrumentKeyPrefix,

[please use gerrit instead, 2017/04/27 15:37:40]

Stringprintf seems like an overkill. Why not this?

std::string CreatePaymentInstrumentKey(const std::string& instrument_key) {
  return "PaymentInstrument:" + instrument_key;
}

+                            instrument_key.c_str());
+}
 
 payments::mojom::PaymentAppManifestPtr DeserializePaymentAppManifest(
     const std::string& input) {
   PaymentAppManifestProto manifest_proto;
   if (!manifest_proto.ParseFromString(input))
     return nullptr;
 
   payments::mojom::PaymentAppManifestPtr manifest =
       payments::mojom::PaymentAppManifest::New();
   manifest->name = manifest_proto.name();
@@ skipping 246 matching lines @@
     DeletePaymentInstrumentCallback callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK) {
     std::move(callback).Run(PaymentHandlerStatus::NO_ACTIVE_WORKER);
     return;
   }
 
   service_worker_context_->GetRegistrationUserData(
-      registration->id(), {instrument_key},
+      registration->id(), {CreatePaymentInstrumentKey(instrument_key)},
       base::Bind(&PaymentAppDatabase::DidFindPaymentInstrument,
                  weak_ptr_factory_.GetWeakPtr(), registration->id(),
                  instrument_key, base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::DidFindPaymentInstrument(
     int64_t registration_id,
     const std::string& instrument_key,
     DeletePaymentInstrumentCallback callback,
     const std::vector<std::string>& data,
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK || data.size() != 1) {
     std::move(callback).Run(PaymentHandlerStatus::NOT_FOUND);
     return;
   }
 
   service_worker_context_->ClearRegistrationUserData(
-      registration_id, {instrument_key},
+      registration_id, {CreatePaymentInstrumentKey(instrument_key)},
       base::Bind(&PaymentAppDatabase::DidDeletePaymentInstrument,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::DidDeletePaymentInstrument(
     DeletePaymentInstrumentCallback callback,
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return std::move(callback).Run(status == SERVICE_WORKER_OK
                                      ? PaymentHandlerStatus::SUCCESS
                                      : PaymentHandlerStatus::NOT_FOUND);
 }
 
 void PaymentAppDatabase::DidFindRegistrationToReadPaymentInstrument(
     const std::string& instrument_key,
     ReadPaymentInstrumentCallback callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK) {
     std::move(callback).Run(PaymentInstrument::New(),
                             PaymentHandlerStatus::NO_ACTIVE_WORKER);
     return;
   }
 
   service_worker_context_->GetRegistrationUserData(
-      registration->id(), {instrument_key},
+      registration->id(), {CreatePaymentInstrumentKey(instrument_key)},
       base::Bind(&PaymentAppDatabase::DidReadPaymentInstrument,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::DidReadPaymentInstrument(
     ReadPaymentInstrumentCallback callback,
     const std::vector<std::string>& data,
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 18 matching lines @@
     HasPaymentInstrumentCallback callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK) {
     std::move(callback).Run(PaymentHandlerStatus::NO_ACTIVE_WORKER);
     return;
   }
 
   service_worker_context_->GetRegistrationUserData(
-      registration->id(), {instrument_key},
+      registration->id(), {CreatePaymentInstrumentKey(instrument_key)},
       base::Bind(&PaymentAppDatabase::DidHasPaymentInstrument,
                  weak_ptr_factory_.GetWeakPtr(), registration->id(),
                  instrument_key, base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::DidHasPaymentInstrument(
     int64_t registration_id,
     const std::string& instrument_key,
     DeletePaymentInstrumentCallback callback,
     const std::vector<std::string>& data,
@@ skipping 26 matching lines @@
   }
   instrument_proto.set_stringified_capabilities(
       instrument->stringified_capabilities);
 
   std::string serialized;
   bool success = instrument_proto.SerializeToString(&serialized);
   DCHECK(success);
 
   service_worker_context_->StoreRegistrationUserData(
       registration->id(), registration->pattern().GetOrigin(),
-      {{instrument_key, serialized}},
+      {{CreatePaymentInstrumentKey(instrument_key), serialized}},
       base::Bind(&PaymentAppDatabase::DidWritePaymentInstrument,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::DidWritePaymentInstrument(
     WritePaymentInstrumentCallback callback,
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return std::move(callback).Run(
       status == SERVICE_WORKER_OK
           ? PaymentHandlerStatus::SUCCESS
           : PaymentHandlerStatus::STORAGE_OPERATION_FAILED);
 }
 
 }  // namespace content