arc-bridge: Make ArcAppModelBuilderTest more reliable

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"
@@ skipping 48 matching lines @@
       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();
+    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 131 matching lines @@
   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, app_instance()->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();
   app_instance()->RefreshAppList();
-  EXPECT_EQ(1, app_instance()->refresh_app_list_count());
+  EXPECT_EQ(2, app_instance()->refresh_app_list_count());
 }
 
 TEST_F(ArcAppModelBuilderTest, RefreshAllFillsContent) {
   ValidateHaveApps(std::vector<arc::AppInfo>());
   bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(fake_apps());
   ValidateHaveApps(fake_apps());
 }
 
@@ skipping 58 matching lines @@
   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);
-
-  // Process pending tasks.
-  base::RunLoop().RunUntilIdle();
+  app_instance()->WaitForIncomingMethodCall();
 
   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.
   app_instance()->SendRefreshAppList(std::vector<arc::AppInfo>());
@@ skipping 26 matching lines @@
       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::FakeAppInstance::IconRequest>& icon_requests =
       app_instance()->icon_requests();
-  EXPECT_EQ(scale_factors.size() * fake_apps().size(), icon_requests.size());
+  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::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());
   }
@@ skipping 53 matching lines @@
 
   // 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);
 }