Convert app banners to use Mojo.

chrome/browser/banners/app_banner_manager.cc

 // 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 "chrome/browser/banners/app_banner_manager.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
+#include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "chrome/browser/banners/app_banner_metrics.h"
 #include "chrome/browser/banners/app_banner_settings_helper.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/engagement/site_engagement_service.h"
-#include "chrome/browser/installable/installable_logging.h"
-#include "chrome/browser/installable/installable_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/render_messages.h"
 #include "components/rappor/rappor_utils.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/origin_util.h"
-#include "third_party/WebKit/public/platform/modules/app_banner/WebAppBannerPromptReply.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
+#include "services/shell/public/cpp/interface_provider.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
+#if defined(OS_ANDROID)
+#include "chrome/browser/android/banners/app_banner_manager_android.h"
+#else
+#include "chrome/browser/banners/app_banner_manager_desktop.h"
+#endif
+
 namespace {
 
 bool gDisableSecureCheckForTesting = false;
 int gCurrentRequestID = -1;
 base::LazyInstance<base::TimeDelta> gTimeDeltaForTesting =
     LAZY_INSTANCE_INITIALIZER;
 
 // Returns |size_in_px| in dp, i.e. divided by the current device scale factor.
 int ConvertIconSizeFromPxToDp(int size_in_px) {
   return size_in_px /
@@ skipping 15 matching lines @@
   params.fetch_valid_icon = true;
 
   return params;
 }
 
 }  // anonymous namespace
 
 namespace banners {
 
 // static
+void AppBannerManager::Create(content::WebContents* web_contents) {
+#if defined(OS_ANDROID)
+  return AppBannerManagerAndroid::CreateForWebContents(web_contents);
+#else
+  return AppBannerManagerDesktop::CreateForWebContents(web_contents);
+#endif
+}
+
+// static
+AppBannerManager* AppBannerManager::Get(content::WebContents* web_contents) {
+#if defined(OS_ANDROID)
+  return AppBannerManagerAndroid::FromWebContents(web_contents);
+#else
+  return AppBannerManagerDesktop::FromWebContents(web_contents);
+#endif
+}
+
+// static
+void AppBannerManager::BindToMojoRequest(
+    content::RenderFrameHost* render_frame_host,
+    blink::mojom::AppBannerServiceRequest request) {
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderFrameHost(render_frame_host);
+  DCHECK(web_contents);
+
+  AppBannerManager* manager = AppBannerManager::Get(web_contents);
+  DCHECK(manager);
+
+  manager->binding_.reset(new mojo::Binding<blink::mojom::AppBannerService>(
+      manager, std::move(request)));
+}
+
+// static
 void AppBannerManager::DisableSecureSchemeCheckForTesting() {
   gDisableSecureCheckForTesting = true;
 }
 
 // static
 base::Time AppBannerManager::GetCurrentTime() {
   return base::Time::Now() + gTimeDeltaForTesting.Get();
 }
 
 // static
@@ skipping 48 matching lines @@
     ReportStatus(contents, NOT_FROM_SECURE_ORIGIN);
     Stop();
     return;
   }
 
   manager_->GetData(
       ParamsToGetManifest(),
       base::Bind(&AppBannerManager::OnDidGetManifest, GetWeakPtr()));
 }
 
+void AppBannerManager::SendBannerAccepted(int request_id) {
+  if (request_id != gCurrentRequestID)
+    return;
+
+  DCHECK(event_->is_bound());
+  (*event_)->BannerAccepted(request_id, GetBannerType());
+}
+
+void AppBannerManager::SendBannerDismissed(int request_id) {
+  if (request_id != gCurrentRequestID)
+    return;
+
+  DCHECK(event_->is_bound());
+  (*event_)->BannerDismissed(request_id);
+}
+
+void AppBannerManager::SetEvent(blink::mojom::AppBannerEventPtr event) {
+  event_.reset(new blink::mojom::AppBannerEventPtr(std::move(event)));
+}
+
 base::Closure AppBannerManager::FetchWebappSplashScreenImageCallback(
     const std::string& webapp_id) {
   return base::Closure();
 }
 
 AppBannerManager::AppBannerManager(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       SiteEngagementObserver(nullptr),
       manager_(nullptr),
       event_request_id_(-1),
@@ skipping 174 matching lines @@
 
   // Given all of the other checks that have been made, the only possible reason
   // for stopping now is that the app has been added to the homescreen.
   if (!IsDebugMode() && !CheckIfShouldShowBanner()) {
     Stop();
     return;
   }
 
   TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_CREATED);
   event_request_id_ = ++gCurrentRequestID;
-  content::RenderFrameHost* frame = web_contents()->GetMainFrame();
-  frame->Send(new ChromeViewMsg_AppBannerPromptRequest(
-      frame->GetRoutingID(), event_request_id_, GetBannerType()));
+
+  web_contents()->GetMainFrame()->GetRemoteInterfaces()->GetInterface(
+      mojo::GetProxy(&banner_client_));
+
+  banner_client_->BannerPromptRequest(
+      event_request_id_, GetBannerType(),
+      base::Bind(&AppBannerManager::OnBannerPromptReply, GetWeakPtr()));
 }
 
 void AppBannerManager::DidStartNavigation(content::NavigationHandle* handle) {
   if (!handle->IsInMainFrame())
     return;
 
   load_finished_ = false;
   if (AppBannerSettingsHelper::ShouldUseSiteEngagementScore() &&
       GetSiteEngagementService() == nullptr) {
     // Ensure that we are observing the site engagement service on navigation
@@ skipping 108 matching lines @@
   }
 
   // If we are in debug mode, AppBannerSettingsHelper::ShouldShowBanner must
   // return NO_ERROR_DETECTED (bypass flag is set) or we must not have entered
   // this method.
   DCHECK(!IsDebugMode());
   ReportStatus(web_contents(), code);
   return false;
 }
 
-bool AppBannerManager::OnMessageReceived(
-    const IPC::Message& message,
-    content::RenderFrameHost* render_frame_host) {
-  bool handled = true;
-
-  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(AppBannerManager, message, render_frame_host)
-    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AppBannerPromptReply,
-                        OnBannerPromptReply)
-    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_RequestShowAppBanner,
-                        OnRequestShowAppBanner)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-
-  return handled;
-}
-
 void AppBannerManager::OnBannerPromptReply(
-    content::RenderFrameHost* render_frame_host,
     int request_id,
-    blink::WebAppBannerPromptReply reply,
-    std::string referrer) {
+    blink::mojom::AppBannerPromptReply reply,
+    mojo::String referrer) {

[Sam McNally, 2016/10/06 07:17:43]

const std::string&

[dominickn, 2016/10/06 22:58:12]

Done.

   content::WebContents* contents = web_contents();
   if (request_id != event_request_id_)
     return;
 
   // The renderer might have requested the prompt to be canceled.
   // They may request that it is redisplayed later, so don't Stop() here.
   // However, log that the cancelation was requested, so Stop() can be
   // called if a redisplay isn't asked for.
   //
   // We use the additional page_requested_prompt_ variable because the redisplay
   // request may be received *before* the Cancel prompt reply (e.g. if redisplay
   // is requested in the beforeinstallprompt event handler).
-  referrer_ = referrer;
-  if (reply == blink::WebAppBannerPromptReply::Cancel &&
+  referrer_ = referrer.get();
+  if (reply == blink::mojom::AppBannerPromptReply::CANCEL &&
       !page_requested_prompt_) {
     TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_PREVENT_DEFAULT_CALLED);
     was_canceled_by_page_ = true;
     return;
   }
 
   // If we haven't yet returned, but either of |was_canceled_by_page_| or
   // |page_requested_prompt_| is true, the page has requested a delayed showing
   // of the prompt. Otherwise, the prompt was never canceled by the page.
   if (was_canceled_by_page_ || page_requested_prompt_) {
@@ skipping 10 matching lines @@
   DCHECK(!manifest_url_.is_empty());
   DCHECK(!manifest_.IsEmpty());
   DCHECK(!icon_url_.is_empty());
   DCHECK(icon_.get());
 
   TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_COMPLETE);
   ShowBanner();
   is_active_ = false;
 }
 
-void AppBannerManager::OnRequestShowAppBanner(
-    content::RenderFrameHost* render_frame_host,
-    int request_id) {
+void AppBannerManager::DisplayAppBanner(int request_id) {
   if (was_canceled_by_page_) {
     // Simulate a non-canceled OnBannerPromptReply to show the delayed banner.
     // Don't reset |was_canceled_by_page_| yet for metrics purposes.
-    OnBannerPromptReply(render_frame_host, request_id,
-                        blink::WebAppBannerPromptReply::None, referrer_);
+    OnBannerPromptReply(request_id, blink::mojom::AppBannerPromptReply::NONE,
+                        referrer_);
   } else {
     // Log that the prompt request was made for when we get the prompt reply.
     page_requested_prompt_ = true;
   }
 }
 
 }  // namespace banners