Convert app banners to use Mojo.

third_party/WebKit/Source/modules/app_banner/AppBannerController.cpp

 // Copyright 2015 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 "modules/app_banner/AppBannerController.h"
 
 #include "core/EventTypeNames.h"
 #include "core/dom/Document.h"
 #include "core/frame/DOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "modules/app_banner/BeforeInstallPromptEvent.h"
-#include "public/platform/WebVector.h"
-#include "public/platform/modules/app_banner/WebAppBannerClient.h"
-#include "public/platform/modules/app_banner/WebAppBannerPromptReply.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "platform/weborigin/KURL.h"
+#include "platform/weborigin/Referrer.h"
+#include "platform/weborigin/SecurityPolicy.h"
+#include "wtf/PtrUtil.h"
+#include "wtf/text/AtomicString.h"
+#include <memory>
+#include <utility>
 
 namespace blink {
 
-// static
-void AppBannerController::willShowInstallBannerPrompt(
-    int requestId,
-    WebAppBannerClient* client,
+AppBannerController::AppBannerController(LocalFrame* frame) : m_frame(frame) {}
+
+void AppBannerController::create(

[haraken, 2016/10/20 15:51:23]

Shall we rename this to createMojoBinding? In Blink, XXX::create is expected to
return a newly created object of XXX.

[dominickn, 2016/10/20 23:41:18]

Renamed to bindMojoRequest, since that seems to be the standard naming for these
things.

     LocalFrame* frame,
-    const WebVector<WebString>& platforms,
-    WebAppBannerPromptReply* reply) {
-  Vector<String> wtfPlatforms;
-  for (const WebString& platform : platforms)
-    wtfPlatforms.append(platform);
+    mojom::blink::AppBannerControllerRequest request) {
+  if (!frame)
+    return;
 
-  // dispatchEvent() returns whether the default behavior can happen. In other
-  // words, it returns false if preventDefault() was called.
-  *reply =
-      frame->domWindow()->dispatchEvent(BeforeInstallPromptEvent::create(
-          EventTypeNames::beforeinstallprompt, frame->document(), wtfPlatforms,
-          requestId, client)) == DispatchEventResult::NotCanceled
-          ? WebAppBannerPromptReply::None
-          : WebAppBannerPromptReply::Cancel;
+  mojo::MakeStrongBinding(wrapUnique(new AppBannerController(frame)),
+                          std::move(request));
+}
+
+void AppBannerController::BannerPromptRequest(
+    mojom::blink::AppBannerServicePtr servicePtr,
+    mojom::blink::AppBannerEventRequest eventRequest,
+    const Vector<String>& platforms,
+    const BannerPromptRequestCallback& callback) {
+  if (!m_frame) {

[haraken, 2016/10/20 08:43:18]

Who clears m_frame when the frame gets detached?

I guess we need to make AppBannerController DOMWindowProperty. Then you can use
frame(). frame() becomes null after the frame gets detached.

[dominickn, 2016/10/20 11:41:34]

I don't think that's necessary. AppBannerController's lifetime is strongly
connected to that of the request (this is what mojo::MakeStrongBinding does in
the ::create method). That means that when the other end of the mojo pipe is
closed, this object is freed.

The AppBannerManager clears its end of the mojo pipe immediately when |callback|
is run in this method, which frees this object. So this object only exists
between the AppBannerManager calling SendBannerPromptRequest, and the completion
of callback.Run(). That should free the persistent reference here.

[haraken, 2016/10/20 15:51:23]

Thanks for the clarification. Makes sense.

+    callback.Run(mojom::blink::AppBannerPromptReply::NONE, "");
+    return;
+  }
+
+  mojom::AppBannerPromptReply reply =
+      m_frame->domWindow()->dispatchEvent(BeforeInstallPromptEvent::create(
+          EventTypeNames::beforeinstallprompt, *m_frame, std::move(servicePtr),
+          std::move(eventRequest), platforms)) ==
+              DispatchEventResult::NotCanceled
+          ? mojom::AppBannerPromptReply::NONE
+          : mojom::AppBannerPromptReply::CANCEL;
+
+  AtomicString referrer = SecurityPolicy::generateReferrer(
+                              m_frame->document()->getReferrerPolicy(), KURL(),
+                              m_frame->document()->outgoingReferrer())
+                              .referrer;
+
+  callback.Run(reply, referrer.isNull() ? emptyString() : referrer);
 }
 
 }  // namespace blink