Reland "arc-bridge: Move most methods to Mojo interfaces"

chrome/browser/ui/app_list/arc/arc_app_unittest.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 <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/ui/app_list/app_list_test_util.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_icon.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_item.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_model_builder.h"
 #include "chrome/browser/ui/app_list/test/test_app_list_controller_delegate.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/arc/arc_bridge_service.h"
+#include "components/arc/test/fake_app_instance.h"
 #include "components/arc/test/fake_arc_bridge_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/app_list_model.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
 
 std::string GetAppId(const arc::AppInfo& app_info) {
   return ArcAppListPrefs::GetAppId(app_info.package, app_info.activity);
@@ skipping 19 matching lines @@
       base::snprintf(buffer, arraysize(buffer), "Fake App %d", i);
       app.name = buffer;
       base::snprintf(buffer, arraysize(buffer), "fake.app.%d", i);
       app.package = buffer;
       base::snprintf(buffer, arraysize(buffer), "fake.app.%d.activity", i);
       app.activity = buffer;
       fake_apps_.push_back(app);
     }
 
     bridge_service_.reset(new arc::FakeArcBridgeService());
+    app_instance_.reset(
+        new arc::FakeAppInstance(ArcAppListPrefs::Get(profile_.get())));
+    arc::AppInstancePtr instance;
+    app_instance_->Bind(mojo::GetProxy(&instance));
+    bridge_service_->OnAppInstanceReady(std::move(instance));
+    // Wait for Init() and then RefreshAppList().
+    app_instance_->WaitForIncomingMethodCall();

[dcheng, 2015/12/20 01:49:45]

Too bad there isn't some sort of way to be more explicit about the calls being
waited for.

[xiyuan, 2015/12/21 17:05:53]

Yeah, this is confusing to read. Can we add something to FakeAppInstance so that
we can wait on Init() and RefreshAppList() explicitly?

For now, it could even just be a wrapper for the two WaitForIncomingMethodCall()
e.g.

void FakeAppInstance::WaitForInitAndRefreshAppList() {
  WaitForIncomingMethodCall();  // Wait for Init call
  WaitForIncomingMethodCall();  // Wait for RefreshAppList call
}

And call this here. This would make it easier to read and the details of
FakeAppInstance stays in FakeAppInstance.

[Luis Héctor Chávez, 2015/12/21 17:24:21]

Done.

+    app_instance_->WaitForIncomingMethodCall();
 
     // Check initial conditions.
     EXPECT_EQ(bridge_service_.get(), arc::ArcBridgeService::Get());
     EXPECT_EQ(true, !arc::ArcBridgeService::Get()->available());
     EXPECT_EQ(arc::ArcBridgeService::State::STOPPED,
               arc::ArcBridgeService::Get()->state());
 
     CreateBuilder();
 
     // At this point we should have ArcAppListPrefs as observer of service.
@@ skipping 109 matching lines @@
 
     // Process the rest of the apps.
     for (auto& id : ids) {
       scoped_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(id);
       ASSERT_NE(nullptr, app_info.get());
       EXPECT_NE(ready, app_info->ready);
       const ArcAppItem* app_item = FindArcItem(id);
       ASSERT_NE(nullptr, app_item);
       EXPECT_NE(ready, app_item->ready());
     }
-
   }
 
   AppListControllerDelegate* controller() { return controller_.get(); }
 
   arc::FakeArcBridgeService* bridge_service() { return bridge_service_.get(); }
 
+  arc::FakeAppInstance* app_instance() { return app_instance_.get(); }
+
   const std::vector<arc::AppInfo>& fake_apps() const { return fake_apps_; }
 
  private:
   scoped_ptr<app_list::AppListModel> model_;
   scoped_ptr<test::TestAppListControllerDelegate> controller_;
   scoped_ptr<ArcAppModelBuilder> builder_;
   scoped_ptr<arc::FakeArcBridgeService> bridge_service_;
+  scoped_ptr<arc::FakeAppInstance> app_instance_;
   std::vector<arc::AppInfo> fake_apps_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcAppModelBuilderTest);
 };
 
 TEST_F(ArcAppModelBuilderTest, RefreshAllOnReady) {
-  EXPECT_EQ(0, bridge_service()->refresh_app_list_count());
+  // There should already have been one call, when the interface was
+  // registered.
+  EXPECT_EQ(1, app_instance()->refresh_app_list_count());
   bridge_service()->SetReady();
-  EXPECT_EQ(1, bridge_service()->refresh_app_list_count());
+  app_instance()->RefreshAppList();
+  EXPECT_EQ(2, app_instance()->refresh_app_list_count());
 }
 
 TEST_F(ArcAppModelBuilderTest, RefreshAllFillsContent) {
   ValidateHaveApps(std::vector<arc::AppInfo>());
   bridge_service()->SetReady();
-  bridge_service()->SendRefreshAppList(fake_apps());
+  app_instance()->RefreshAppList();
+  app_instance()->SendRefreshAppList(fake_apps());
   ValidateHaveApps(fake_apps());
 }
 
 TEST_F(ArcAppModelBuilderTest, MultipleRefreshAll) {
   ValidateHaveApps(std::vector<arc::AppInfo>());
   bridge_service()->SetReady();
+  app_instance()->RefreshAppList();
   // Send info about all fake apps except last.
   std::vector<arc::AppInfo> apps1(fake_apps().begin(), fake_apps().end() - 1);
-  bridge_service()->SendRefreshAppList(apps1);
+  app_instance()->SendRefreshAppList(apps1);
   // At this point all apps (except last) should exist and be ready.
   ValidateHaveApps(apps1);
   ValidateAppReadyState(apps1, true);
 
   // Send info about all fake apps except first.
   std::vector<arc::AppInfo> apps2(fake_apps().begin() + 1, fake_apps().end());
-  bridge_service()->SendRefreshAppList(apps2);
+  app_instance()->SendRefreshAppList(apps2);
   // At this point all apps should exist but first one should be non-ready.
   ValidateHaveApps(fake_apps());
   ValidateAppReadyState(apps2, true);
 
   // Send info about all fake apps.
-  bridge_service()->SendRefreshAppList(fake_apps());
+  app_instance()->SendRefreshAppList(fake_apps());
   // At this point all apps should exist and be ready.
   ValidateHaveApps(fake_apps());
   ValidateAppReadyState(fake_apps(), true);
 
   // Send info no app available.
-  bridge_service()->SendRefreshAppList(std::vector<arc::AppInfo>());
+  app_instance()->SendRefreshAppList(std::vector<arc::AppInfo>());
   // At this point all apps should exist and be non-ready.
   ValidateHaveApps(fake_apps());
   ValidateAppReadyState(fake_apps(), false);
 }
 
 TEST_F(ArcAppModelBuilderTest, StopServiceDisablesApps) {
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
   bridge_service()->SetReady();
+  app_instance()->RefreshAppList();
   EXPECT_EQ(static_cast<size_t>(0), GetArcItemCount());
   EXPECT_EQ(static_cast<size_t>(0), prefs->GetAppIds().size());
 
-  bridge_service()->SendRefreshAppList(fake_apps());
+  app_instance()->SendRefreshAppList(fake_apps());
   std::vector<std::string> ids = prefs->GetAppIds();
   EXPECT_EQ(fake_apps().size(), ids.size());
   ValidateAppReadyState(fake_apps(), true);
 
   // Stopping service does not delete items. It makes them non-ready.
   bridge_service()->SetStopped();
   // Ids should be the same.
   EXPECT_EQ(ids, prefs->GetAppIds());
   ValidateAppReadyState(fake_apps(), false);
 }
 
 TEST_F(ArcAppModelBuilderTest, LaunchApps) {
   // Disable attempts to dismiss app launcher view.
   ChromeAppListItem::OverrideAppListControllerDelegateForTesting(controller());
 
   bridge_service()->SetReady();
-  bridge_service()->SendRefreshAppList(fake_apps());
+  app_instance()->RefreshAppList();
+  app_instance()->SendRefreshAppList(fake_apps());
 
   // Simulate item activate.
   const arc::AppInfo& app_first = fake_apps()[0];
   const arc::AppInfo& app_last = fake_apps()[0];
   ArcAppItem* item_first = FindArcItem(GetAppId(app_first));
   ArcAppItem* item_last = FindArcItem(GetAppId(app_last));
   ASSERT_NE(nullptr, item_first);
   ASSERT_NE(nullptr, item_last);
   item_first->Activate(0);
+  app_instance()->WaitForIncomingMethodCall();
   item_last->Activate(0);
+  app_instance()->WaitForIncomingMethodCall();
   item_first->Activate(0);
+  app_instance()->WaitForIncomingMethodCall();
 
-  const ScopedVector<arc::FakeArcBridgeService::Request>& launch_requests =
-      bridge_service()->launch_requests();
-  EXPECT_EQ(static_cast<size_t>(3), launch_requests.size());
+  const ScopedVector<arc::FakeAppInstance::Request>& launch_requests =
+      app_instance()->launch_requests();
+  ASSERT_EQ(static_cast<size_t>(3), launch_requests.size());
   EXPECT_EQ(true, launch_requests[0]->IsForApp(app_first));
   EXPECT_EQ(true, launch_requests[1]->IsForApp(app_last));
   EXPECT_EQ(true, launch_requests[2]->IsForApp(app_first));
 
   // Test an attempt to launch of a not-ready app.
-  bridge_service()->SendRefreshAppList(std::vector<arc::AppInfo>());
+  app_instance()->SendRefreshAppList(std::vector<arc::AppInfo>());
   item_first = FindArcItem(GetAppId(app_first));
   ASSERT_NE(nullptr, item_first);
-  size_t launch_request_count_before =
-      bridge_service()->launch_requests().size();
+  size_t launch_request_count_before = app_instance()->launch_requests().size();
   item_first->Activate(0);
   // Number of launch requests must not change.
   EXPECT_EQ(launch_request_count_before,
-            bridge_service()->launch_requests().size());
+            app_instance()->launch_requests().size());
 }
 
 TEST_F(ArcAppModelBuilderTest, RequestIcons) {
   // Make sure we are on UI thread.
   ASSERT_EQ(true,
             content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   bridge_service()->SetReady();
-  bridge_service()->SendRefreshAppList(fake_apps());
+  app_instance()->RefreshAppList();
+  app_instance()->SendRefreshAppList(fake_apps());
 
   // Validate that no icon exists at the beginning and request icon for
   // each supported scale factor. This will start asynchronous loading.
   uint32_t expected_mask = 0;
   const std::vector<ui::ScaleFactor>& scale_factors =
       ui::GetSupportedScaleFactors();
   for (auto& scale_factor : scale_factors) {
     expected_mask |= 1 <<  scale_factor;
     for (auto& app : fake_apps()) {
       ArcAppItem* app_item = FindArcItem(GetAppId(app));
       ASSERT_NE(nullptr, app_item);
       const float scale = ui::GetScaleForScaleFactor(scale_factor);
       app_item->icon().GetRepresentation(scale);
     }
   }
 
   // Process pending tasks.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
+  // Normally just one call to RunUntilIdle() suffices to make sure
+  // all RequestAppIcon() calls are delivered, but on slower machines
+  // (especially when running under Valgrind), they might not get
+  // delivered on time. Wait for the remaining tasks individually.
+  const size_t expected_size = scale_factors.size() * fake_apps().size();
+  while (app_instance()->icon_requests().size() < expected_size) {
+    app_instance()->WaitForIncomingMethodCall();
+  }
 
   // At this moment we should receive all requests for icon loading.
-  const ScopedVector<arc::FakeArcBridgeService::IconRequest>& icon_requests =
-      bridge_service()->icon_requests();
-  EXPECT_EQ(scale_factors.size() * fake_apps().size(), icon_requests.size());
+  const ScopedVector<arc::FakeAppInstance::IconRequest>& icon_requests =
+      app_instance()->icon_requests();
+  EXPECT_EQ(expected_size, icon_requests.size());
   std::map<std::string, uint32_t> app_masks;
   for (size_t i = 0; i < icon_requests.size(); ++i) {
-    const arc::FakeArcBridgeService::IconRequest* icon_request =
-        icon_requests[i];
+    const arc::FakeAppInstance::IconRequest* icon_request = icon_requests[i];
     const std::string id = ArcAppListPrefs::GetAppId(icon_request->package(),
                                                      icon_request->activity());
     // Make sure no double requests.
     EXPECT_NE(app_masks[id],
               app_masks[id] | (1 << icon_request->scale_factor()));
     app_masks[id] |= (1 << icon_request->scale_factor());
   }
 
   // Validate that we have a request for each icon for each supported scale
   // factor.
   EXPECT_EQ(fake_apps().size(), app_masks.size());
   for (auto& app : fake_apps()) {
     const std::string id = GetAppId(app);
     ASSERT_NE(app_masks.find(id), app_masks.end());
     EXPECT_EQ(app_masks[id], expected_mask);
   }
 }
 
 TEST_F(ArcAppModelBuilderTest, InstallIcon) {
   // Make sure we are on UI thread.
   ASSERT_EQ(true,
             content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
 
   bridge_service()->SetReady();
-  bridge_service()->SendRefreshAppList(std::vector<arc::AppInfo>(
-      fake_apps().begin(), fake_apps().begin() + 1));
+  app_instance()->RefreshAppList();
+  app_instance()->SendRefreshAppList(
+      std::vector<arc::AppInfo>(fake_apps().begin(), fake_apps().begin() + 1));
   const arc::AppInfo& app = fake_apps()[0];
 
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
   const ui::ScaleFactor scale_factor = ui::GetSupportedScaleFactors()[0];
   const float scale = ui::GetScaleForScaleFactor(scale_factor);
   const base::FilePath icon_path = prefs->GetIconPath(GetAppId(app),
                                                       scale_factor);
   EXPECT_EQ(true, !base::PathExists(icon_path));
 
   const ArcAppItem* app_item = FindArcItem(GetAppId(app));
   EXPECT_NE(nullptr, app_item);
   // This initiates async loading.
   app_item->icon().GetRepresentation(scale);
 
   // Process pending tasks.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
   // Validating decoded content does not fit well for unit tests.
   ArcAppIcon::DisableDecodingForTesting();
 
   // Now send generated icon for the app.
   std::string png_data;
-  EXPECT_EQ(true, bridge_service()->GenerateAndSendIcon(
-      app,
-      static_cast<arc::ScaleFactor>(scale_factor),
-      &png_data));
+  EXPECT_EQ(true,
+            app_instance()->GenerateAndSendIcon(
+                app, static_cast<arc::ScaleFactor>(scale_factor), &png_data));
 
   // Process pending tasks.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
   // Validate that icons are installed, have right content and icon is
   // refreshed for ARC app item.
   EXPECT_EQ(true, base::PathExists(icon_path));
 
   std::string icon_data;
   // Read the file from disk and compare with reference data.
   EXPECT_EQ(true, base::ReadFileToString(icon_path, &icon_data));
   ASSERT_EQ(icon_data, png_data);
 }