Use web-app manifest format for Android payment apps.

components/payments/content/payment_manifest_downloader.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 "components/payments/content/payment_manifest_downloader.h"
 
 #include <algorithm>
 #include <unordered_map>
 #include <utility>
 
@@ skipping 13 matching lines @@
 namespace {
 
 bool IsValidManifestUrl(const GURL& url) {
   return url.is_valid() && url.SchemeIs(url::kHttpsScheme);
 }
 
 }  // namespace
 
 PaymentManifestDownloader::PaymentManifestDownloader(
     const scoped_refptr<net::URLRequestContextGetter>& context,
-    const GURL& method_name,
+    const GURL& url,
     Delegate* delegate)
     : context_(context),
-      method_name_(method_name),
+      url_(url),
       delegate_(delegate),
       is_downloading_http_link_header_(true) {
-  DCHECK(IsValidManifestUrl(method_name_));
+  DCHECK(IsValidManifestUrl(url_));
 }
 
 PaymentManifestDownloader::~PaymentManifestDownloader() {}
 
-void PaymentManifestDownloader::Download() {
-  InitiateDownload(method_name_, net::URLFetcher::HEAD);
+void PaymentManifestDownloader::DownloadPaymentMethodManifest() {
+  DCHECK(!fetcher_);
+  is_downloading_http_link_header_ = true;
+  InitiateDownload(url_, net::URLFetcher::HEAD);
+}
+
+void PaymentManifestDownloader::DownloadWebAppManifest() {
+  DCHECK(!fetcher_);
+  is_downloading_http_link_header_ = false;
+  InitiateDownload(url_, net::URLFetcher::GET);
 }
 
 void PaymentManifestDownloader::InitiateDownload(
     const GURL& url,
     net::URLFetcher::RequestType request_type) {
   if (!IsValidManifestUrl(url)) {
     delegate_->OnManifestDownloadFailure();
     return;
   }
 
@@ skipping 19 matching lines @@
 
     net::HttpResponseHeaders* headers = source->GetResponseHeaders();
     if (!headers) {
       delegate_->OnManifestDownloadFailure();
       return;
     }
 
     std::string link_header;
     headers->GetNormalizedHeader("link", &link_header);
     if (!link_header.empty()) {
-      std::string manifest_url;
+      std::string payment_method_manifest_url;
       std::unordered_map<std::string, base::Optional<std::string>> params;
       for (const auto& value : link_header_util::SplitLinkHeader(link_header)) {
-        if (!link_header_util::ParseLinkHeaderValue(value.first, value.second,
-                                                    &manifest_url, &params)) {
+        if (!link_header_util::ParseLinkHeaderValue(
+                value.first, value.second, &payment_method_manifest_url,
+                &params)) {
           continue;
         }
 
         auto rel = params.find("rel");
         if (rel == params.end())
           continue;
 
         std::vector<std::string> rel_parts =
             base::SplitString(rel->second.value_or(""), HTTP_LWS,
                               base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
         if (std::find(rel_parts.begin(), rel_parts.end(),
                       "payment-method-manifest") != rel_parts.end()) {
-          InitiateDownload(method_name_.Resolve(manifest_url),
+          InitiateDownload(url_.Resolve(payment_method_manifest_url),
                            net::URLFetcher::GET);
           return;
         }
       }
     }
   } else {
     std::string content;
     if (source->GetResponseAsString(&content) && !content.empty()) {
       delegate_->OnManifestDownloadSuccess(content);
       return;
     }
   }
 
   delegate_->OnManifestDownloadFailure();
 }
 
 }  // namespace payments