expect the test finishes

chrome/browser/extensions/requirements_checker_browsertest.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 29 matching lines @@
     scoped_refptr<const Extension> extension = file_util::LoadExtension(
         extension_path, Manifest::UNPACKED, 0, &load_error);
     CHECK_EQ(0U, load_error.length());
     return extension;
   }
 
   void ValidateRequirementErrors(
       const std::vector<std::string>& expected_errors,
       const std::vector<std::string>& actual_errors) {
     ASSERT_EQ(expected_errors, actual_errors);
+    finished_ = true;
   }
 
   // This should only be called once per test instance. Calling more than once
   // will result in stale information in the GPUDataManager which will throw off
   // the RequirementsChecker.
   void BlackListGPUFeatures(const std::vector<std::string>& features) {
 #if !defined(NDEBUG)
     static bool called = false;
     DCHECK(!called);
     called = true;
@@ skipping 10 matching lines @@
       "    }\n"
       "  ]\n"
       "}";
     gpu::GPUInfo gpu_info;
     content::GpuDataManager::GetInstance()->InitializeForTesting(
         json_blacklist, gpu_info);
   }
 
  protected:
   std::unique_ptr<RequirementsChecker> checker_;
+  bool finished_ = false;
 };
 
 IN_PROC_BROWSER_TEST_F(RequirementsCheckerBrowserTest, CheckEmptyExtension) {
   scoped_refptr<const Extension> extension(
       LoadExtensionFromDirName("no_requirements"));
   ASSERT_TRUE(extension.get());
   checker_->Check(extension, base::Bind(
       &RequirementsCheckerBrowserTest::ValidateRequirementErrors,
       base::Unretained(this), std::vector<std::string>()));
   content::RunAllBlockingPoolTasksUntilIdle();
+  EXPECT_TRUE(finished_);
 }
 
 IN_PROC_BROWSER_TEST_F(RequirementsCheckerBrowserTest, CheckNpapiExtension) {
   scoped_refptr<const Extension> extension(
       LoadExtensionFromDirName("require_npapi"));
   ASSERT_TRUE(extension.get());
 
   std::vector<std::string> expected_errors;
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   expected_errors.push_back(l10n_util::GetStringUTF8(
       IDS_EXTENSION_NPAPI_NOT_SUPPORTED));
 #endif
 
   checker_->Check(extension, base::Bind(
       &RequirementsCheckerBrowserTest::ValidateRequirementErrors,
       base::Unretained(this), expected_errors));
   content::RunAllBlockingPoolTasksUntilIdle();
+  EXPECT_TRUE(finished_);
 }
 
 IN_PROC_BROWSER_TEST_F(RequirementsCheckerBrowserTest,
                        CheckWindowShapeExtension) {
   scoped_refptr<const Extension> extension(
       LoadExtensionFromDirName("require_window_shape"));
   ASSERT_TRUE(extension.get());
 
   std::vector<std::string> expected_errors;
 #if !defined(USE_AURA)
   expected_errors.push_back(l10n_util::GetStringUTF8(
       IDS_EXTENSION_WINDOW_SHAPE_NOT_SUPPORTED));
 #endif  // !defined(USE_AURA)
 
   checker_->Check(extension, base::Bind(
       &RequirementsCheckerBrowserTest::ValidateRequirementErrors,
       base::Unretained(this), expected_errors));
   content::RunAllBlockingPoolTasksUntilIdle();
+  EXPECT_TRUE(finished_);
 }
 
 IN_PROC_BROWSER_TEST_F(RequirementsCheckerBrowserTest, DisallowWebGL) {
   scoped_refptr<const Extension> extension(
       LoadExtensionFromDirName("require_3d"));
   ASSERT_TRUE(extension.get());
 
   // Backlist webgl
   std::vector<std::string> blacklisted_features;
   blacklisted_features.push_back("accelerated_webgl");
   BlackListGPUFeatures(blacklisted_features);
   content::RunAllBlockingPoolTasksUntilIdle();
 
   std::vector<std::string> expected_errors;
   expected_errors.push_back(l10n_util::GetStringUTF8(
       IDS_EXTENSION_WEBGL_NOT_SUPPORTED));
 
   checker_->Check(extension, base::Bind(
       &RequirementsCheckerBrowserTest::ValidateRequirementErrors,
       base::Unretained(this), expected_errors));
   content::RunAllBlockingPoolTasksUntilIdle();
+  EXPECT_TRUE(finished_);
 }
 
 IN_PROC_BROWSER_TEST_F(RequirementsCheckerBrowserTest, Check3DExtension) {
   scoped_refptr<const Extension> extension(
       LoadExtensionFromDirName("require_3d"));
   ASSERT_TRUE(extension.get());
 
   std::vector<std::string> expected_errors;
 
   if (!content::GpuDataManager::GetInstance()->GpuAccessAllowed(NULL)) {
     expected_errors.push_back(l10n_util::GetStringUTF8(
         IDS_EXTENSION_WEBGL_NOT_SUPPORTED));
   }
 
   checker_->Check(extension, base::Bind(
       &RequirementsCheckerBrowserTest::ValidateRequirementErrors,
       base::Unretained(this), expected_errors));
   content::RunAllBlockingPoolTasksUntilIdle();
+  EXPECT_TRUE(finished_);
 }
 
 }  // namespace extensions