Pass in extra parameters to WebApkBuilder#buildWebApkAsync()

content/renderer/manifest/manifest_manager.cc

 // Copyright 2014 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/renderer/manifest/manifest_manager.h"
 
 #include "base/bind.h"
 #include "base/strings/nullable_string16.h"
 #include "content/common/manifest_manager_messages.h"
 #include "content/public/renderer/render_frame.h"
@@ skipping 41 matching lines @@
   bool has_manifest = may_have_manifest_ && !url.is_empty();
   Send(new ManifestManagerHostMsg_HasManifestResponse(
       routing_id(), request_id, has_manifest));
 }
 
 void ManifestManager::OnRequestManifest(int request_id) {
   GetManifest(base::Bind(&ManifestManager::OnRequestManifestComplete,
                          base::Unretained(this), request_id));
 }
 
-void ManifestManager::OnRequestManifestComplete(
-    int request_id, const Manifest& manifest,
-    const ManifestDebugInfo&) {
+void ManifestManager::OnRequestManifestComplete(int request_id,
+                                                const GURL& manifest_url,
+                                                const Manifest& manifest,
+                                                const ManifestDebugInfo&) {
   // When sent via IPC, the Manifest must follow certain security rules.
   Manifest ipc_manifest = manifest;
   ipc_manifest.name = base::NullableString16(
       ipc_manifest.name.string().substr(0, Manifest::kMaxIPCStringLength),
       ipc_manifest.name.is_null());
   ipc_manifest.short_name = base::NullableString16(
         ipc_manifest.short_name.string().substr(0,
                                                 Manifest::kMaxIPCStringLength),
         ipc_manifest.short_name.is_null());
   for (auto& icon : ipc_manifest.icons) {
     icon.type = base::NullableString16(
         icon.type.string().substr(0, Manifest::kMaxIPCStringLength),
         icon.type.is_null());
   }
   ipc_manifest.gcm_sender_id = base::NullableString16(
         ipc_manifest.gcm_sender_id.string().substr(
             0, Manifest::kMaxIPCStringLength),
         ipc_manifest.gcm_sender_id.is_null());
   for (auto& related_application : ipc_manifest.related_applications) {
     related_application.id =
         base::NullableString16(related_application.id.string().substr(
                                    0, Manifest::kMaxIPCStringLength),
                                related_application.id.is_null());
   }
 
   Send(new ManifestManagerHostMsg_RequestManifestResponse(
-      routing_id(), request_id, ipc_manifest));
+      routing_id(), request_id, manifest_url, ipc_manifest));
 }
 
 void ManifestManager::GetManifest(const GetManifestCallback& callback) {
   if (!may_have_manifest_) {
-    callback.Run(Manifest(), ManifestDebugInfo());
+    callback.Run(GURL(), Manifest(), ManifestDebugInfo());
     return;
   }
 
   if (!manifest_dirty_) {
-    callback.Run(manifest_, manifest_debug_info_);
+    callback.Run(manifest_url_, manifest_, manifest_debug_info_);
     return;
   }
 
   pending_callbacks_.push_back(callback);
 
   // Just wait for the running call to be done if there are other callbacks.
   if (pending_callbacks_.size() > 1)
     return;
 
   FetchManifest();
@@ skipping 68 matching lines @@
     render_frame()->GetWebFrame()->addMessageToConsole(message);
   }
 
   // Having errors while parsing the manifest doesn't mean the manifest parsing
   // failed. Some properties might have been ignored but some others kept.
   if (parser.failed()) {
     ResolveCallbacks(ResolveStateFailure);
     return;
   }
 
+  manifest_url_ = response.url();
   manifest_ = parser.manifest();
   ResolveCallbacks(ResolveStateSuccess);
 }
 
 void ManifestManager::ResolveCallbacks(ResolveState state) {
-  if (state == ResolveStateFailure)
+  if (state == ResolveStateFailure) {
+    manifest_url_ = GURL();
     manifest_ = Manifest();
+  }
 
   manifest_dirty_ = state != ResolveStateSuccess;
 
   std::list<GetManifestCallback> callbacks;
   callbacks.swap(pending_callbacks_);
 
   for (std::list<GetManifestCallback>::const_iterator it = callbacks.begin();
        it != callbacks.end(); ++it) {
-    it->Run(manifest_, manifest_debug_info_);
+    it->Run(manifest_url_, manifest_, manifest_debug_info_);
   }
 }
 
 void ManifestManager::OnDestruct() {
   delete this;
 }
 
 } // namespace content