Create PendingScriptClient as a separate client interface for PendingScript.

third_party/WebKit/Source/bindings/core/v8/ScriptStreamerTest.cpp

 // 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 "bindings/core/v8/ScriptStreamer.h"
 
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/ScriptStreamerThread.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
@@ skipping 73 matching lines @@
   WebTaskRunner* m_loadingTaskRunner;  // NOT OWNED
   std::unique_ptr<Settings> m_settings;
   // The Resource and PendingScript where we stream from. These don't really
   // fetch any data outside the test; the test controls the data by calling
   // ScriptResource::appendData.
   ResourceRequest m_resourceRequest;
   Persistent<ScriptResource> m_resource;
   Persistent<PendingScript> m_pendingScript;
 };
 
-class TestScriptResourceClient
-    : public GarbageCollectedFinalized<TestScriptResourceClient>,
-      public ScriptResourceClient {
-  USING_GARBAGE_COLLECTED_MIXIN(TestScriptResourceClient);
+class TestPendingScriptClient
+    : public GarbageCollectedFinalized<TestPendingScriptClient>,
+      public PendingScriptClient {
+  USING_GARBAGE_COLLECTED_MIXIN(TestPendingScriptClient);
 
  public:
-  TestScriptResourceClient() : m_finished(false) {}
-
-  void notifyFinished(Resource*) override { m_finished = true; }
-  String debugName() const override { return "TestScriptResourceClient"; }
-
+  TestPendingScriptClient() : m_finished(false) {}
+  void pendingScriptFinished(PendingScript*) override { m_finished = true; }
   bool finished() const { return m_finished; }
 
  private:
   bool m_finished;
 };
 
 TEST_F(ScriptStreamingTest, CompilingStreamedScript) {
   // Test that we can successfully compile a streamed script.
   V8TestingScope scope;
   ScriptStreamer::startStreaming(
       getPendingScript(), ScriptStreamer::ParsingBlocking, m_settings.get(),
       scope.getScriptState(), m_loadingTaskRunner);
-  TestScriptResourceClient* client = new TestScriptResourceClient;
+  TestPendingScriptClient* client = new TestPendingScriptClient;
   getPendingScript()->watchForLoad(client);
 
   appendData("function foo() {");
   appendPadding();
   appendData("return 5; }");
   appendPadding();
   appendData("foo();");
   EXPECT_FALSE(client->finished());
   finish();
 
@@ skipping 14 matching lines @@
 }
 
 TEST_F(ScriptStreamingTest, CompilingStreamedScriptWithParseError) {
   // Test that scripts with parse errors are handled properly. In those cases,
   // the V8 side typically finished before loading finishes: make sure we
   // handle it gracefully.
   V8TestingScope scope;
   ScriptStreamer::startStreaming(
       getPendingScript(), ScriptStreamer::ParsingBlocking, m_settings.get(),
       scope.getScriptState(), m_loadingTaskRunner);
-  TestScriptResourceClient* client = new TestScriptResourceClient;
+  TestPendingScriptClient* client = new TestPendingScriptClient;
   getPendingScript()->watchForLoad(client);
   appendData("function foo() {");
   appendData("this is the part which will be a parse error");
   // V8 won't realize the parse error until it actually starts parsing the
   // script, and this happens only when its buffer is filled.
   appendPadding();
 
   EXPECT_FALSE(client->finished());
 
   // Force the V8 side to finish before the loading.
@@ skipping 15 matching lines @@
   EXPECT_TRUE(tryCatch.HasCaught());
 }
 
 TEST_F(ScriptStreamingTest, CancellingStreaming) {
   // Test that the upper layers (PendingScript and up) can be ramped down
   // while streaming is ongoing, and ScriptStreamer handles it gracefully.
   V8TestingScope scope;
   ScriptStreamer::startStreaming(
       getPendingScript(), ScriptStreamer::ParsingBlocking, m_settings.get(),
       scope.getScriptState(), m_loadingTaskRunner);
-  TestScriptResourceClient* client = new TestScriptResourceClient;
+  TestPendingScriptClient* client = new TestPendingScriptClient;
   getPendingScript()->watchForLoad(client);
   appendData("function foo() {");
 
   // In general, we cannot control what the background thread is doing
   // (whether it's parsing or waiting for more data). In this test, we have
   // given it so little data that it's surely waiting for more.
 
   // Simulate cancelling the network load (e.g., because the user navigated
   // away).
   EXPECT_FALSE(client->finished());
   getPendingScript()->dispose();
   m_pendingScript = nullptr;  // This will destroy m_resource.
   m_resource = nullptr;
 
   // The V8 side will complete too. This should not crash. We don't receive
   // any results from the streaming and the client doesn't get notified.
   processTasksUntilStreamingComplete();
   EXPECT_FALSE(client->finished());
 }
 
 TEST_F(ScriptStreamingTest, SuppressingStreaming) {
   // If we notice during streaming that there is a code cache, streaming
   // is suppressed (V8 doesn't parse while the script is loading), and the
   // upper layer (ScriptResourceClient) should get a notification when the
   // script is loaded.
   V8TestingScope scope;
   ScriptStreamer::startStreaming(
       getPendingScript(), ScriptStreamer::ParsingBlocking, m_settings.get(),
       scope.getScriptState(), m_loadingTaskRunner);
-  TestScriptResourceClient* client = new TestScriptResourceClient;
+  TestPendingScriptClient* client = new TestPendingScriptClient;
   getPendingScript()->watchForLoad(client);
   appendData("function foo() {");
   appendPadding();
 
   CachedMetadataHandler* cacheHandler = m_resource->cacheHandler();
   EXPECT_TRUE(cacheHandler);
   cacheHandler->setCachedMetadata(V8ScriptRunner::tagForCodeCache(cacheHandler),
                                   "X", 1, CachedMetadataHandler::CacheLocally);
 
   appendPadding();
@@ skipping 12 matching lines @@
 }
 
 TEST_F(ScriptStreamingTest, EmptyScripts) {
   // Empty scripts should also be streamed properly, that is, the upper layer
   // (ScriptResourceClient) should be notified when an empty script has been
   // loaded.
   V8TestingScope scope;
   ScriptStreamer::startStreaming(
       getPendingScript(), ScriptStreamer::ParsingBlocking, m_settings.get(),
       scope.getScriptState(), m_loadingTaskRunner);
-  TestScriptResourceClient* client = new TestScriptResourceClient;
+  TestPendingScriptClient* client = new TestPendingScriptClient;
   getPendingScript()->watchForLoad(client);
 
   // Finish the script without sending any data.
   finish();
   // The finished notification should arrive immediately and not be cycled
   // through a background thread.
   EXPECT_TRUE(client->finished());
 
   bool errorOccurred = false;
   ScriptSourceCode sourceCode =
       getPendingScript()->getSource(KURL(), errorOccurred);
   EXPECT_FALSE(errorOccurred);
   EXPECT_FALSE(sourceCode.streamer());
 }
 
 TEST_F(ScriptStreamingTest, SmallScripts) {
   // Small scripts shouldn't be streamed.
   V8TestingScope scope;
   ScriptStreamer::setSmallScriptThresholdForTesting(100);
 
   ScriptStreamer::startStreaming(
       getPendingScript(), ScriptStreamer::ParsingBlocking, m_settings.get(),
       scope.getScriptState(), m_loadingTaskRunner);
-  TestScriptResourceClient* client = new TestScriptResourceClient;
+  TestPendingScriptClient* client = new TestPendingScriptClient;
   getPendingScript()->watchForLoad(client);
 
   appendData("function foo() { }");
 
   finish();
 
   // The finished notification should arrive immediately and not be cycled
   // through a background thread.
   EXPECT_TRUE(client->finished());
 
   bool errorOccurred = false;
   ScriptSourceCode sourceCode =
       getPendingScript()->getSource(KURL(), errorOccurred);
   EXPECT_FALSE(errorOccurred);
   EXPECT_FALSE(sourceCode.streamer());
 }
 
 TEST_F(ScriptStreamingTest, ScriptsWithSmallFirstChunk) {
   // If a script is long enough, if should be streamed, even if the first data
   // chunk is small.
   V8TestingScope scope;
   ScriptStreamer::setSmallScriptThresholdForTesting(100);
 
   ScriptStreamer::startStreaming(
       getPendingScript(), ScriptStreamer::ParsingBlocking, m_settings.get(),
       scope.getScriptState(), m_loadingTaskRunner);
-  TestScriptResourceClient* client = new TestScriptResourceClient;
+  TestPendingScriptClient* client = new TestPendingScriptClient;
   getPendingScript()->watchForLoad(client);
 
   // This is the first data chunk which is small.
   appendData("function foo() { }");
   appendPadding();
   appendPadding();
   appendPadding();
 
   finish();
 
@@ skipping 13 matching lines @@
 
 TEST_F(ScriptStreamingTest, EncodingChanges) {
   // It's possible that the encoding of the Resource changes after we start
   // loading it.
   V8TestingScope scope;
   m_resource->setEncoding("windows-1252");
 
   ScriptStreamer::startStreaming(
       getPendingScript(), ScriptStreamer::ParsingBlocking, m_settings.get(),
       scope.getScriptState(), m_loadingTaskRunner);
-  TestScriptResourceClient* client = new TestScriptResourceClient;
+  TestPendingScriptClient* client = new TestPendingScriptClient;
   getPendingScript()->watchForLoad(client);
 
   m_resource->setEncoding("UTF-8");
   // \xec\x92\x81 are the raw bytes for \uc481.
   appendData(
       "function foo() { var foob\xec\x92\x81r = 13; return foob\xec\x92\x81r; "
       "} foo();");
 
   finish();
 
@@ skipping 14 matching lines @@
 TEST_F(ScriptStreamingTest, EncodingFromBOM) {
   // Byte order marks should be removed before giving the data to V8. They
   // will also affect encoding detection.
   V8TestingScope scope;
   m_resource->setEncoding(
       "windows-1252");  // This encoding is wrong on purpose.
 
   ScriptStreamer::startStreaming(
       getPendingScript(), ScriptStreamer::ParsingBlocking, m_settings.get(),
       scope.getScriptState(), m_loadingTaskRunner);
-  TestScriptResourceClient* client = new TestScriptResourceClient;
+  TestPendingScriptClient* client = new TestPendingScriptClient;
   getPendingScript()->watchForLoad(client);
 
   // \xef\xbb\xbf is the UTF-8 byte order mark. \xec\x92\x81 are the raw bytes
   // for \uc481.
   appendData(
       "\xef\xbb\xbf function foo() { var foob\xec\x92\x81r = 13; return "
       "foob\xec\x92\x81r; } foo();");
 
   finish();
   processTasksUntilStreamingComplete();
   EXPECT_TRUE(client->finished());
   bool errorOccurred = false;
   ScriptSourceCode sourceCode =
       getPendingScript()->getSource(KURL(), errorOccurred);
   EXPECT_FALSE(errorOccurred);
   EXPECT_TRUE(sourceCode.streamer());
   v8::TryCatch tryCatch(scope.isolate());
   v8::Local<v8::Script> script;
   EXPECT_TRUE(V8ScriptRunner::compileScript(sourceCode, scope.isolate())
                   .ToLocal(&script));
   EXPECT_FALSE(tryCatch.HasCaught());
 }
 
 }  // namespace
 
 }  // namespace blink