Change V8CacheOnCacheStorage tests to wait for the V8 code cache to be written.

content/browser/service_worker/service_worker_browsertest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
@@ skipping 1763 matching lines @@
 class ServiceWorkerV8CacheStrategiesTest : public ServiceWorkerBrowserTest {
  public:
   ServiceWorkerV8CacheStrategiesTest() {}
   ~ServiceWorkerV8CacheStrategiesTest() override {}
 
  protected:
   void CheckStrategyIsNone() {
     RegisterAndActivateServiceWorker();
 
     NavigateToTestPage();
-    EXPECT_EQ(0, GetSideDataSize());
+    WaitUntilSideDataSizeIs(0);
 
     NavigateToTestPage();
-    EXPECT_EQ(0, GetSideDataSize());
+    WaitUntilSideDataSizeIs(0);
 
     NavigateToTestPage();
-    EXPECT_EQ(0, GetSideDataSize());
+    WaitUntilSideDataSizeIs(0);
   }
 
   void CheckStrategyIsNormal() {
     RegisterAndActivateServiceWorker();
 
     NavigateToTestPage();
     // fetch_event_response_via_cache.js returns |cloned_response| for the first
     // load. So the V8 code cache should not be stored to the CacheStorage.
-    EXPECT_EQ(0, GetSideDataSize());
+    WaitUntilSideDataSizeIs(0);
 
     NavigateToTestPage();
     // V8ScriptRunner::setCacheTimeStamp() stores 12 byte data (tag +
     // timestamp).
-    EXPECT_EQ(kV8CacheTimeStampDataSize, GetSideDataSize());
+    WaitUntilSideDataSizeIs(kV8CacheTimeStampDataSize);
 
     NavigateToTestPage();
     // The V8 code cache must be stored to the CacheStorage which must be bigger
     // than 12 byte.
-    EXPECT_GT(GetSideDataSize(), kV8CacheTimeStampDataSize);
+    WaitUntilSideDataSizeIsBiggerThan(kV8CacheTimeStampDataSize);
   }
 
   void CheckStrategyIsAggressive() {
     RegisterAndActivateServiceWorker();
 
     NavigateToTestPage();
     // fetch_event_response_via_cache.js returns |cloned_response| for the first
     // load. So the V8 code cache should not be stored to the CacheStorage.
-    EXPECT_EQ(0, GetSideDataSize());
+    WaitUntilSideDataSizeIs(0);
 
     NavigateToTestPage();
     // The V8 code cache must be stored to the CacheStorage which must be bigger
     // than 12 byte.
-    EXPECT_GT(GetSideDataSize(), kV8CacheTimeStampDataSize);
+    WaitUntilSideDataSizeIsBiggerThan(kV8CacheTimeStampDataSize);
 
     NavigateToTestPage();
-    EXPECT_GT(GetSideDataSize(), kV8CacheTimeStampDataSize);
+    WaitUntilSideDataSizeIsBiggerThan(kV8CacheTimeStampDataSize);
   }
 
  private:
   static const std::string kPageUrl;
   static const std::string kWorkerUrl;
   static const std::string kScriptUrl;
   static const int kV8CacheTimeStampDataSize;
 
   void RegisterAndActivateServiceWorker() {
     scoped_refptr<WorkerActivatedObserver> observer =
@@ skipping 17 matching lines @@
   int GetSideDataSize() {
     StoragePartition* partition = BrowserContext::GetDefaultStoragePartition(
         shell()->web_contents()->GetBrowserContext());
     return CacheStorageSideDataSizeChecker::GetSize(
         static_cast<CacheStorageContextImpl*>(
             partition->GetCacheStorageContext()),
         partition->GetFileSystemContext(), embedded_test_server()->base_url(),
         std::string("cache_name"), embedded_test_server()->GetURL(kScriptUrl));
   }
 
+  void WaitUntilSideDataSizeIs(int expected_size) {
+    while (true) {

[shimazu, 2016/08/03 06:06:54]

I feel better to have timeout not to get stuck in infinite loop situation. What
do you think?

[horo, 2016/08/03 10:33:26]

The testing framework has its own timeout logic (base/test/test_timeouts.h).
So I think we should not implement here.
For example, TitleWatcher doesn't have a timeout logic.

[shimazu, 2016/08/08 02:30:44]

I see, thanks!

+      if (GetSideDataSize() == expected_size)
+        return;
+    }
+  }
+
+  void WaitUntilSideDataSizeIsBiggerThan(int minimum_size) {
+    while (true) {
+      if (GetSideDataSize() > minimum_size)
+        return;
+    }
+  }
+
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerV8CacheStrategiesTest);
 };
 
 const std::string ServiceWorkerV8CacheStrategiesTest::kPageUrl =
     "/service_worker/v8_cache_test.html";
 const std::string ServiceWorkerV8CacheStrategiesTest::kWorkerUrl =
     "/service_worker/fetch_event_response_via_cache.js";
 const std::string ServiceWorkerV8CacheStrategiesTest::kScriptUrl =
     "/service_worker/v8_cache_test.js";
 // V8ScriptRunner::setCacheTimeStamp() stores 12 byte data (tag + timestamp).
@@ skipping 134 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerDisableWebSecurityTest, UpdateNoCrash) {
   const char kPageUrl[] = "/service_worker/disable_web_security_update.html";
   const char kScopeUrl[] = "/service_worker/scope/";
   const char kWorkerUrl[] = "/service_worker/fetch_event_blob.js";
   RegisterServiceWorkerOnCrossOriginServer(kScopeUrl, kWorkerUrl);
   RunTestWithCrossOriginURL(kPageUrl, kScopeUrl);
 }
 
 }  // namespace content