Convert ManifestManager IPCs to Mojo.

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"
 #include "content/renderer/fetchers/manifest_fetcher.h"
 #include "content/renderer/manifest/manifest_parser.h"
 #include "content/renderer/manifest/manifest_uma_util.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 namespace content {
 
 ManifestManager::ManifestManager(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       may_have_manifest_(false),
       manifest_dirty_(true) {
 }
 
 ManifestManager::~ManifestManager() {
   if (fetcher_)
     fetcher_->Cancel();
 
   // Consumers in the browser process will not receive this message but they
   // will be aware of the RenderFrame dying and should act on that. Consumers
   // in the renderer process should be correctly notified.
   ResolveCallbacks(ResolveStateFailure);
 }
 
-bool ManifestManager::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
+void ManifestManager::HasManifest(const HasManifestCallback& callback) {
+  GURL url(render_frame()->GetWebFrame()->document().manifestURL());
 
-  IPC_BEGIN_MESSAGE_MAP(ManifestManager, message)
-    IPC_MESSAGE_HANDLER(ManifestManagerMsg_HasManifest, OnHasManifest)
-    IPC_MESSAGE_HANDLER(ManifestManagerMsg_RequestManifest, OnRequestManifest)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-
-  return handled;
+  callback.Run(may_have_manifest_ && !url.is_empty());
 }
 
-void ManifestManager::OnHasManifest(int request_id) {
-  GURL url(render_frame()->GetWebFrame()->document().manifestURL());
-
-  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) {
+void ManifestManager::RequestManifest(const RequestManifestCallback& callback) {
   GetManifest(base::Bind(&ManifestManager::OnRequestManifestComplete,
-                         base::Unretained(this), request_id));
+                         base::Unretained(this), callback));
 }
 
 void ManifestManager::OnRequestManifestComplete(
-    int request_id, const Manifest& manifest,
+    const RequestManifestCallback& callback,
+    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));
+  callback.Run(manifest);
 }
 
 void ManifestManager::GetManifest(const GetManifestCallback& callback) {
   if (!may_have_manifest_) {
     callback.Run(Manifest(), ManifestDebugInfo());
     return;
   }
 
   if (!manifest_dirty_) {
     callback.Run(manifest_, manifest_debug_info_);
@@ skipping 88 matching lines @@
   manifest_ = parser.manifest();
   ResolveCallbacks(ResolveStateSuccess);
 }
 
 void ManifestManager::ResolveCallbacks(ResolveState state) {
   if (state == ResolveStateFailure)
     manifest_ = Manifest();
 
   manifest_dirty_ = state != ResolveStateSuccess;
 
-  std::list<GetManifestCallback> callbacks;
-  callbacks.swap(pending_callbacks_);
+  Manifest manifest = manifest_;
+  std::vector<GetManifestCallback> callbacks = std::move(pending_callbacks_);
+  pending_callbacks_.clear();
 
-  for (std::list<GetManifestCallback>::const_iterator it = callbacks.begin();
-       it != callbacks.end(); ++it) {
-    it->Run(manifest_, manifest_debug_info_);
-  }
+  for (const auto& callback : callbacks)
+    callback.Run(manifest, manifest_debug_info_);
+}
+
+void ManifestManager::BindToRequest(
+    blink::mojom::ManifestManagerRequest request) {
+  bindings_.AddBinding(this, std::move(request));
 }
 
 void ManifestManager::OnDestruct() {
   delete this;
 }
 
-} // namespace content
+}  // namespace content