OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/payments/payment_app_manager.h" | 5 #include "content/browser/payments/payment_app_manager.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/optional.h" | 10 #include "base/optional.h" |
11 #include "content/browser/payments/payment_app.pb.h" | 11 #include "content/browser/payments/payment_app.pb.h" |
12 #include "content/browser/payments/payment_app_context_impl.h" | 12 #include "content/browser/payments/payment_app_context.h" |
13 #include "content/browser/service_worker/service_worker_context_wrapper.h" | 13 #include "content/browser/service_worker/service_worker_context_wrapper.h" |
14 #include "content/browser/service_worker/service_worker_registration.h" | 14 #include "content/browser/service_worker/service_worker_registration.h" |
15 #include "content/public/browser/browser_thread.h" | 15 #include "content/public/browser/browser_thread.h" |
16 | 16 |
17 namespace content { | 17 namespace content { |
| 18 namespace { |
| 19 |
| 20 const char kPaymentAppManifestDataKey[] = "PaymentAppManifestData"; |
| 21 |
| 22 } // namespace |
18 | 23 |
19 PaymentAppManager::~PaymentAppManager() { | 24 PaymentAppManager::~PaymentAppManager() { |
20 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 25 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
21 } | 26 } |
22 | 27 |
23 PaymentAppManager::PaymentAppManager( | 28 PaymentAppManager::PaymentAppManager( |
24 PaymentAppContextImpl* payment_app_context, | 29 PaymentAppContext* payment_app_context, |
25 mojo::InterfaceRequest<payments::mojom::PaymentAppManager> request) | 30 mojo::InterfaceRequest<payments::mojom::PaymentAppManager> request) |
26 : payment_app_context_(payment_app_context), | 31 : payment_app_context_(payment_app_context), |
27 binding_(this, std::move(request)), | 32 binding_(this, std::move(request)), |
28 weak_ptr_factory_(this) { | 33 weak_ptr_factory_(this) { |
29 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 34 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
30 DCHECK(payment_app_context); | 35 DCHECK(payment_app_context); |
31 | 36 |
32 binding_.set_connection_error_handler( | 37 binding_.set_connection_error_handler( |
33 base::Bind(&PaymentAppManager::OnConnectionError, | 38 base::Bind(&PaymentAppManager::OnConnectionError, |
34 base::Unretained(this))); | 39 base::Unretained(this))); |
35 } | 40 } |
36 | 41 |
| 42 void PaymentAppManager::OnConnectionError() { |
| 43 payment_app_context_->ServiceHadConnectionError(this); |
| 44 } |
| 45 |
37 void PaymentAppManager::SetManifest( | 46 void PaymentAppManager::SetManifest( |
38 const std::string& scope, | 47 const std::string& scope, |
39 payments::mojom::PaymentAppManifestPtr manifest, | 48 payments::mojom::PaymentAppManifestPtr manifest, |
40 const SetManifestCallback& callback) { | 49 const SetManifestCallback& callback) { |
41 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 50 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
42 | 51 |
43 // TODO(zino): Should implement requesting a permission for users to allow | 52 // TODO(zino): Should implement requesting a permission for users to allow |
44 // the payment app to be registered. Please see http://crbug.com/665949. | 53 // the payment app to be registered. Please see http://crbug.com/665949. |
45 | 54 |
46 payment_app_context_->payment_app_database()->WriteManifest( | 55 payment_app_context_->service_worker_context() |
47 GURL(scope), std::move(manifest), callback); | 56 ->FindReadyRegistrationForPattern( |
| 57 GURL(scope), |
| 58 base::Bind(&PaymentAppManager::DidFindRegistrationToSetManifest, |
| 59 weak_ptr_factory_.GetWeakPtr(), |
| 60 base::Passed(std::move(manifest)), callback)); |
48 } | 61 } |
49 | 62 |
50 void PaymentAppManager::GetManifest(const std::string& scope, | 63 void PaymentAppManager::GetManifest(const std::string& scope, |
51 const GetManifestCallback& callback) { | 64 const GetManifestCallback& callback) { |
52 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 65 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
53 | 66 |
54 payment_app_context_->payment_app_database()->ReadManifest(GURL(scope), | 67 payment_app_context_->service_worker_context() |
55 callback); | 68 ->FindReadyRegistrationForPattern( |
| 69 GURL(scope), |
| 70 base::Bind(&PaymentAppManager::DidFindRegistrationToGetManifest, |
| 71 weak_ptr_factory_.GetWeakPtr(), callback)); |
56 } | 72 } |
57 | 73 |
58 void PaymentAppManager::OnConnectionError() { | 74 void PaymentAppManager::DidFindRegistrationToSetManifest( |
59 payment_app_context_->ServiceHadConnectionError(this); | 75 payments::mojom::PaymentAppManifestPtr manifest, |
| 76 const SetManifestCallback& callback, |
| 77 ServiceWorkerStatusCode status, |
| 78 scoped_refptr<ServiceWorkerRegistration> registration) { |
| 79 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 80 if (status != SERVICE_WORKER_OK) { |
| 81 callback.Run(payments::mojom::PaymentAppManifestError::NO_ACTIVE_WORKER); |
| 82 return; |
| 83 } |
| 84 |
| 85 PaymentAppManifestProto manifest_proto; |
| 86 manifest_proto.set_label(manifest->label); |
| 87 if (manifest->icon) |
| 88 manifest_proto.set_icon(manifest->icon.value()); |
| 89 |
| 90 for (const auto& option : manifest->options) { |
| 91 PaymentAppOptionProto* option_proto = manifest_proto.add_options(); |
| 92 option_proto->set_label(option->label); |
| 93 if (option->icon) |
| 94 option_proto->set_icon(option->icon.value()); |
| 95 option_proto->set_id(option->id); |
| 96 for (const auto& method : option->enabled_methods) { |
| 97 option_proto->add_enabled_methods(method); |
| 98 } |
| 99 } |
| 100 |
| 101 std::string serialized; |
| 102 bool success = manifest_proto.SerializeToString(&serialized); |
| 103 DCHECK(success); |
| 104 |
| 105 payment_app_context_->service_worker_context()->StoreRegistrationUserData( |
| 106 registration->id(), registration->pattern().GetOrigin(), |
| 107 {{kPaymentAppManifestDataKey, serialized}}, |
| 108 base::Bind(&PaymentAppManager::DidSetManifest, |
| 109 weak_ptr_factory_.GetWeakPtr(), callback)); |
| 110 } |
| 111 |
| 112 void PaymentAppManager::DidSetManifest(const SetManifestCallback& callback, |
| 113 ServiceWorkerStatusCode status) { |
| 114 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 115 return callback.Run(status == SERVICE_WORKER_OK |
| 116 ? payments::mojom::PaymentAppManifestError::NONE |
| 117 : payments::mojom::PaymentAppManifestError:: |
| 118 MANIFEST_STORAGE_OPERATION_FAILED); |
| 119 } |
| 120 |
| 121 void PaymentAppManager::DidFindRegistrationToGetManifest( |
| 122 const GetManifestCallback& callback, |
| 123 ServiceWorkerStatusCode status, |
| 124 scoped_refptr<ServiceWorkerRegistration> registration) { |
| 125 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 126 if (status != SERVICE_WORKER_OK) { |
| 127 callback.Run(payments::mojom::PaymentAppManifest::New(), |
| 128 payments::mojom::PaymentAppManifestError::NO_ACTIVE_WORKER); |
| 129 return; |
| 130 } |
| 131 |
| 132 payment_app_context_->service_worker_context()->GetRegistrationUserData( |
| 133 registration->id(), {kPaymentAppManifestDataKey}, |
| 134 base::Bind(&PaymentAppManager::DidGetManifest, |
| 135 weak_ptr_factory_.GetWeakPtr(), callback)); |
| 136 } |
| 137 |
| 138 void PaymentAppManager::DidGetManifest(const GetManifestCallback& callback, |
| 139 const std::vector<std::string>& data, |
| 140 ServiceWorkerStatusCode status) { |
| 141 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 142 if (status != SERVICE_WORKER_OK || data.size() != 1) { |
| 143 callback.Run(payments::mojom::PaymentAppManifest::New(), |
| 144 payments::mojom::PaymentAppManifestError:: |
| 145 MANIFEST_STORAGE_OPERATION_FAILED); |
| 146 return; |
| 147 } |
| 148 |
| 149 PaymentAppManifestProto manifest_proto; |
| 150 bool success = manifest_proto.ParseFromString(data[0]); |
| 151 if (!success) { |
| 152 callback.Run(payments::mojom::PaymentAppManifest::New(), |
| 153 payments::mojom::PaymentAppManifestError:: |
| 154 MANIFEST_STORAGE_OPERATION_FAILED); |
| 155 return; |
| 156 } |
| 157 |
| 158 payments::mojom::PaymentAppManifestPtr manifest = |
| 159 payments::mojom::PaymentAppManifest::New(); |
| 160 manifest->label = manifest_proto.label(); |
| 161 if (manifest_proto.has_icon()) |
| 162 manifest->icon = manifest_proto.icon(); |
| 163 for (const auto& option_proto : manifest_proto.options()) { |
| 164 payments::mojom::PaymentAppOptionPtr option = |
| 165 payments::mojom::PaymentAppOption::New(); |
| 166 option->label = option_proto.label(); |
| 167 if (option_proto.has_icon()) |
| 168 option->icon = option_proto.icon(); |
| 169 option->id = option_proto.id(); |
| 170 for (const auto& method : option_proto.enabled_methods()) |
| 171 option->enabled_methods.push_back(method); |
| 172 manifest->options.push_back(std::move(option)); |
| 173 } |
| 174 |
| 175 callback.Run(std::move(manifest), |
| 176 payments::mojom::PaymentAppManifestError::NONE); |
60 } | 177 } |
61 | 178 |
62 } // namespace content | 179 } // namespace content |
OLD | NEW |