Convert app banners to use Mojo.

chrome/browser/banners/app_banner_manager_browsertest.cc

 // Copyright 2016 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 <memory>
 
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/banners/app_banner_manager.h"
 #include "chrome/browser/banners/app_banner_metrics.h"
 #include "chrome/browser/banners/app_banner_settings_helper.h"
 #include "chrome/browser/installable/installable_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/common/content_switches.h"
+#include "mojo/public/cpp/bindings/binding.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "services/shell/public/cpp/interface_registry.h"
+#include "third_party/WebKit/public/platform/modules/app_banner/app_banner.mojom.h"
 
 namespace banners {
 
 // All calls to RequestAppBanner should terminate in one of Stop() (not showing
 // banner) or ShowBanner(). This browser test uses this and overrides those two
 // methods to capture this information.
 class AppBannerManagerTest : public AppBannerManager {
  public:
   explicit AppBannerManagerTest(content::WebContents* web_contents)
       : AppBannerManager(web_contents) {}
   ~AppBannerManagerTest() override {}
 
+  void BindHandle(mojo::ScopedMessagePipeHandle handle) {
+    binding_.reset(new mojo::Binding<blink::mojom::AppBannerService>(
+        this,
+        mojo::MakeRequest<blink::mojom::AppBannerService>(std::move(handle))));
+  }
+
   bool will_show() { return will_show_.get() && *will_show_; }
 
   bool is_active() { return AppBannerManager::is_active(); }
 
   // Set the page transition of each banner request.
   void set_page_transition_(ui::PageTransition transition) {
     last_transition_type_ = transition;
   }
 
   using AppBannerManager::RequestAppBanner;
@@ skipping 30 matching lines @@
 
   void DidFinishLoad(content::RenderFrameHost* render_frame_host,
                      const GURL& validated_url) override {
     // Do nothing else to ensure the banner pipeline doesn't start.
     validated_url_ = validated_url;
   }
 
  private:
   bool IsDebugMode() const override { return false; }
 
+  std::unique_ptr<mojo::Binding<blink::mojom::AppBannerService>> binding_;
+
   base::Closure quit_closure_;
   std::unique_ptr<bool> will_show_;
 };
 
 class AppBannerManagerBrowserTest : public InProcessBrowserTest {
  public:
   void SetUpOnMainThread() override {
     AppBannerSettingsHelper::SetEngagementWeights(1, 1);
     AppBannerSettingsHelper::SetTotalEngagementToTrigger(2);
     ASSERT_TRUE(embedded_test_server()->Start());
     InProcessBrowserTest::SetUpOnMainThread();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     // Make sure app banners are disabled in the browser, otherwise they will
     // interfere with the test.
     command_line->AppendSwitch(switches::kDisableAddToShelf);
   }
 
  protected:
   void RequestAppBanner(AppBannerManagerTest* manager,
-                        const GURL& url,
+                        content::WebContents* web_contents,
                         base::RunLoop& run_loop,
                         ui::PageTransition transition,
                         bool expected_to_show) {
+    // Intercept the app banner Mojo requests, since
+    // AppBannerManager::BindToMojoRequest does not bind this test class.
+    web_contents->GetMainFrame()->GetInterfaceRegistry()->AddInterface(
+        blink::mojom::AppBannerService::Name_,
+        base::Bind(&AppBannerManagerTest::BindHandle,
+                   base::Unretained(manager)));
+
     manager->set_page_transition_(transition);
-    manager->RequestAppBanner(url, false, run_loop.QuitClosure());
+    manager->RequestAppBanner(web_contents->GetLastCommittedURL(), false,
+                              run_loop.QuitClosure());
     run_loop.Run();
 
     EXPECT_EQ(expected_to_show, manager->will_show());
     ASSERT_FALSE(manager->is_active());
 
     // If showing the banner, ensure that the minutes histogram is recorded.
     histograms_.ExpectTotalCount(banners::kMinutesHistogram,
                                 (manager->will_show() ? 1 : 0));
   }
 
@@ skipping 13 matching lines @@
     std::string valid_page(url);
     GURL test_url = embedded_test_server()->GetURL(valid_page);
     content::WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     std::unique_ptr<AppBannerManagerTest> manager(
         new AppBannerManagerTest(web_contents));
 
     for (unsigned int i = 1; i <= unshown_repetitions; ++i) {
       ui_test_utils::NavigateToURL(browser(), test_url);
       base::RunLoop run_loop;
-      RequestAppBanner(manager.get(), web_contents->GetLastCommittedURL(),
-                       run_loop, transition, false);
+      RequestAppBanner(manager.get(), web_contents, run_loop, transition,
+                       false);
       CheckInstallableStatusCodeHistogram(INSUFFICIENT_ENGAGEMENT, i, i);
       AppBannerManager::SetTimeDeltaForTesting(i);
     }
 
     // On the final loop, check whether the banner triggered or not as expected.
     ui_test_utils::NavigateToURL(browser(), test_url);
     base::RunLoop run_loop;
-    RequestAppBanner(manager.get(), web_contents->GetLastCommittedURL(),
-                     run_loop, transition, expected_to_show);
+    RequestAppBanner(manager.get(), web_contents, run_loop, transition,
+                     expected_to_show);
     // Navigate to ensure the InstallableStatusCodeHistogram is logged.
     ui_test_utils::NavigateToURL(browser(), GURL("about:blank"));
     CheckInstallableStatusCodeHistogram(expected_code_for_histogram, 1,
                                         unshown_repetitions + 1);
     EXPECT_FALSE(manager->need_to_log_status());
   }
 
   void CheckInstallableStatusCodeHistogram(InstallableStatusCode expected_code,
                                            int expected_count,
                                            int total_count) {
@@ skipping 106 matching lines @@
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   std::unique_ptr<AppBannerManagerTest> manager(
       new AppBannerManagerTest(web_contents));
 
   // Add a direct nav on day 1.
   {
     base::RunLoop run_loop;
     ui_test_utils::NavigateToURL(browser(), test_url);
-    RequestAppBanner(manager.get(), web_contents->GetLastCommittedURL(),
-                     run_loop, ui::PAGE_TRANSITION_TYPED, false);
+    RequestAppBanner(manager.get(), web_contents, run_loop,
+                     ui::PAGE_TRANSITION_TYPED, false);
     CheckInstallableStatusCodeHistogram(INSUFFICIENT_ENGAGEMENT, 1, 1);
     EXPECT_FALSE(manager->need_to_log_status());
   }
 
   // Add an indirect nav on day 1 which is ignored.
   {
     base::RunLoop run_loop;
     ui_test_utils::NavigateToURL(browser(), test_url);
-    RequestAppBanner(manager.get(), web_contents->GetLastCommittedURL(),
-                     run_loop, ui::PAGE_TRANSITION_LINK, false);
+    RequestAppBanner(manager.get(), web_contents, run_loop,
+                     ui::PAGE_TRANSITION_LINK, false);
     CheckInstallableStatusCodeHistogram(INSUFFICIENT_ENGAGEMENT, 2, 2);
     EXPECT_FALSE(manager->need_to_log_status());
     AppBannerManager::SetTimeDeltaForTesting(1);
   }
 
   // Add an indirect nav on day 2.
   {
     base::RunLoop run_loop;
     ui_test_utils::NavigateToURL(browser(), test_url);
-    RequestAppBanner(manager.get(), web_contents->GetLastCommittedURL(),
-                     run_loop, ui::PAGE_TRANSITION_MANUAL_SUBFRAME, false);
+    RequestAppBanner(manager.get(), web_contents, run_loop,
+                     ui::PAGE_TRANSITION_MANUAL_SUBFRAME, false);
     CheckInstallableStatusCodeHistogram(INSUFFICIENT_ENGAGEMENT, 3, 3);
     EXPECT_FALSE(manager->need_to_log_status());
   }
 
   // Add a direct nav on day 2 which overrides.
   {
     base::RunLoop run_loop;
     ui_test_utils::NavigateToURL(browser(), test_url);
-    RequestAppBanner(manager.get(), web_contents->GetLastCommittedURL(),
-                     run_loop, ui::PAGE_TRANSITION_GENERATED, false);
+    RequestAppBanner(manager.get(), web_contents, run_loop,
+                     ui::PAGE_TRANSITION_GENERATED, false);
     CheckInstallableStatusCodeHistogram(INSUFFICIENT_ENGAGEMENT, 4, 4);
     EXPECT_FALSE(manager->need_to_log_status());
     AppBannerManager::SetTimeDeltaForTesting(2);
   }
 
   // Add a direct nav on day 3.
   {
     base::RunLoop run_loop;
     ui_test_utils::NavigateToURL(browser(), test_url);
-    RequestAppBanner(manager.get(), web_contents->GetLastCommittedURL(),
-                     run_loop, ui::PAGE_TRANSITION_GENERATED, false);
+    RequestAppBanner(manager.get(), web_contents, run_loop,
+                     ui::PAGE_TRANSITION_GENERATED, false);
     CheckInstallableStatusCodeHistogram(INSUFFICIENT_ENGAGEMENT, 5, 5);
     EXPECT_FALSE(manager->need_to_log_status());
     AppBannerManager::SetTimeDeltaForTesting(3);
   }
 
   // Add an indirect nav on day 4.
   {
     base::RunLoop run_loop;
     ui_test_utils::NavigateToURL(browser(), test_url);
-    RequestAppBanner(manager.get(), web_contents->GetLastCommittedURL(),
-                     run_loop, ui::PAGE_TRANSITION_FORM_SUBMIT, false);
+    RequestAppBanner(manager.get(), web_contents, run_loop,
+                     ui::PAGE_TRANSITION_FORM_SUBMIT, false);
     EXPECT_FALSE(manager->need_to_log_status());
     CheckInstallableStatusCodeHistogram(INSUFFICIENT_ENGAGEMENT, 6, 6);
   }
 
   // Add a direct nav on day 4 which should trigger the banner.
   {
     base::RunLoop run_loop;
     ui_test_utils::NavigateToURL(browser(), test_url);
-    RequestAppBanner(manager.get(), web_contents->GetLastCommittedURL(),
-                     run_loop, ui::PAGE_TRANSITION_TYPED, true);
+    RequestAppBanner(manager.get(), web_contents, run_loop,
+                     ui::PAGE_TRANSITION_TYPED, true);
     EXPECT_FALSE(manager->need_to_log_status());
     CheckInstallableStatusCodeHistogram(SHOWING_WEB_APP_BANNER, 1, 7);
   }
 }
 
 IN_PROC_BROWSER_TEST_F(AppBannerManagerBrowserTest,
                        WebAppBannerNoTypeInManifest) {
   RunBannerTest(GetURLOfPageWithServiceWorkerAndManifest(
                     "/banners/manifest_no_type.json"),
                 ui::PAGE_TRANSITION_TYPED, 1, SHOWING_WEB_APP_BANNER, true);
@@ skipping 37 matching lines @@
   RunBannerTest("/banners/prompt_in_handler_test_page.html",
                 ui::PAGE_TRANSITION_TYPED, 1, SHOWING_WEB_APP_BANNER, true);
 }
 
 IN_PROC_BROWSER_TEST_F(AppBannerManagerBrowserTest, WebAppBannerInIFrame) {
   RunBannerTest("/banners/iframe_test_page.html", ui::PAGE_TRANSITION_TYPED, 0,
                 NO_MANIFEST, false);
 }
 
 }  // namespace banners