Reland of Split PendingScript into PendingScript and ClassicPendingScript

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 <memory>
 
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/ScriptStreamerThread.h"
 #include "bindings/core/v8/V8BindingForCore.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
+#include "core/dom/ClassicPendingScript.h"
 #include "core/dom/ClassicScript.h"
-#include "core/dom/Element.h"
-#include "core/dom/PendingScript.h"
 #include "core/frame/Settings.h"
 #include "platform/heap/Handle.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
 namespace blink {
 
 namespace {
 
 class ScriptStreamingTest : public ::testing::Test {
  public:
   ScriptStreamingTest()
       : loading_task_runner_(Platform::Current()
                                  ->CurrentThread()
                                  ->Scheduler()
                                  ->LoadingTaskRunner()),
         settings_(Settings::Create()),
         resource_request_("http://www.streaming-test.com/"),
         resource_(ScriptResource::Create(resource_request_, "UTF-8")),
-        pending_script_(PendingScript::CreateForTesting(resource_.Get())) {
+        pending_script_(
+            ClassicPendingScript::CreateForTesting(resource_.Get())) {
     resource_->SetStatus(ResourceStatus::kPending);
-    pending_script_ = PendingScript::CreateForTesting(resource_.Get());
+    pending_script_ = ClassicPendingScript::CreateForTesting(resource_.Get());
     ScriptStreamer::SetSmallScriptThresholdForTesting(0);
   }
 
   ~ScriptStreamingTest() {
     if (pending_script_)
       pending_script_->Dispose();
   }
 
-  PendingScript* GetPendingScript() const { return pending_script_.Get(); }
+  ClassicPendingScript* GetPendingScript() const {
+    return pending_script_.Get();
+  }
 
  protected:
   void AppendData(const char* data) {
     resource_->AppendData(data, strlen(data));
     // Yield control to the background thread, so that V8 gets a chance to
     // process the data before the main thread adds more. Note that we
     // cannot fully control in what kind of chunks the data is passed to V8
     // (if V8 is not requesting more data between two appendData calls, it
     // will get both chunks together).
     testing::YieldCurrentThread();
@@ skipping 22 matching lines @@
     testing::RunPendingTasks();
   }
 
   RefPtr<WebTaskRunner> loading_task_runner_;
   std::unique_ptr<Settings> 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 resource_request_;
   Persistent<ScriptResource> resource_;
-  Persistent<PendingScript> pending_script_;
+  Persistent<ClassicPendingScript> pending_script_;
 };
 
 class TestPendingScriptClient
     : public GarbageCollectedFinalized<TestPendingScriptClient>,
       public PendingScriptClient {
   USING_GARBAGE_COLLECTED_MIXIN(TestPendingScriptClient);
 
  public:
   TestPendingScriptClient() : finished_(false) {}
   void PendingScriptFinished(PendingScript*) override { finished_ = true; }
@@ skipping 301 matching lines @@
   EXPECT_TRUE(V8ScriptRunner::CompileScript(source_code, scope.GetIsolate(),
                                             kSharableCrossOrigin,
                                             kV8CacheOptionsDefault)
                   .ToLocal(&script));
   EXPECT_FALSE(try_catch.HasCaught());
 }
 
 }  // namespace
 
 }  // namespace blink