Remove WorkerScriptLoaderClient and inheritances

Source/web/WebSharedWorkerImpl.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 61 matching lines @@
 #include "web/WebDataSourceImpl.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WorkerContentSettingsClient.h"
 #include "wtf/Functional.h"
 #include "wtf/MainThread.h"
 
 namespace blink {
 
 // TODO(toyoshim): Share implementation with WebEmbeddedWorkerImpl as much as
 // possible.
-// A thin wrapper for one-off script loading.
-class WebSharedWorkerImpl::Loader : public WorkerScriptLoaderClient {
-public:
-    static PassOwnPtr<Loader> create()
-    {
-        return adoptPtr(new Loader());
-    }
-
-    virtual ~Loader()
-    {
-        m_scriptLoader->setClient(0);
-    }
-
-    void load(ExecutionContext* loadingContext, const KURL& scriptURL, PassOwnPtr<Closure> receiveResponseCallback, PassOwnPtr<Closure> finishCallback)
-    {
-        ASSERT(loadingContext);
-        m_receiveResponseCallback = receiveResponseCallback;
-        m_finishCallback = finishCallback;
-        m_scriptLoader->setRequestContext(WebURLRequest::RequestContextSharedWorker);
-        m_scriptLoader->loadAsynchronously(
-            *loadingContext, scriptURL, DenyCrossOriginRequests, this);
-    }
-
-    void didReceiveResponse(unsigned long identifier, const ResourceResponse& response) override
-    {
-        m_identifier = identifier;
-        m_appCacheID = response.appCacheID();
-        (*m_receiveResponseCallback)();
-    }
-
-    virtual void notifyFinished() override
-    {
-        (*m_finishCallback)();
-    }
-
-    void cancel()
-    {
-        m_scriptLoader->cancel();
-    }
-
-    bool failed() const { return m_scriptLoader->failed(); }
-    const KURL& url() const { return m_scriptLoader->responseURL(); }
-    String script() const { return m_scriptLoader->script(); }
-    unsigned long identifier() const { return m_identifier; }
-    long long appCacheID() const { return m_appCacheID; }
-    PassRefPtr<ContentSecurityPolicy> contentSecurityPolicy() { return m_scriptLoader->contentSecurityPolicy(); }
-
-private:
-    Loader()
-        : m_scriptLoader(WorkerScriptLoader::create())
-        , m_identifier(0)
-        , m_appCacheID(0)
-    {
-        m_scriptLoader->setContentSecurityPolicy(ContentSecurityPolicy::create());
-    }
-
-    RefPtr<WorkerScriptLoader> m_scriptLoader;
-    unsigned long m_identifier;
-    long long m_appCacheID;
-    OwnPtr<Closure> m_receiveResponseCallback;
-    OwnPtr<Closure> m_finishCallback;
-};
 
 // This function is called on the main thread to force to initialize some static
 // values used in WebKit before any worker thread is started. This is because in
 // our worker processs, we do not run any WebKit code in main thread and thus
 // when multiple workers try to start at the same time, we might hit crash due
 // to contention for initializing static values.
 static void initializeWebKitStaticValues()
 {
     static bool initialized = false;
     if (!initialized) {
@@ skipping 92 matching lines @@
 {
     if (m_networkProvider)
         m_networkProvider->willSendRequest(frame->dataSource(), request);
 }
 
 void WebSharedWorkerImpl::didFinishDocumentLoad(WebLocalFrame* frame)
 {
     ASSERT(!m_loadingDocument);
     ASSERT(!m_mainScriptLoader);
     m_networkProvider = adoptPtr(m_client->createServiceWorkerNetworkProvider(frame->dataSource()));
-    m_mainScriptLoader = Loader::create();
+    m_mainScriptLoader = adoptPtr(new WorkerScriptLoader());
+    m_mainScriptLoader->setRequestContext(WebURLRequest::RequestContextSharedWorker);
     m_loadingDocument = toWebLocalFrameImpl(frame)->frame()->document();
-    m_mainScriptLoader->load(
-        m_loadingDocument.get(),
+    m_mainScriptLoader->loadAsynchronously(
+        *m_loadingDocument.get(),
         m_url,
+        DenyCrossOriginRequests,
         bind(&WebSharedWorkerImpl::didReceiveScriptLoaderResponse, this),
         bind(&WebSharedWorkerImpl::onScriptLoaderFinished, this));
 }
 
 bool WebSharedWorkerImpl::isControlledByServiceWorker(WebDataSource& dataSource)
 {
     return m_networkProvider && m_networkProvider->isControlledByServiceWorker(dataSource);
 }
 
 int64_t WebSharedWorkerImpl::serviceWorkerID(WebDataSource& dataSource)
@@ skipping 133 matching lines @@
     if (InspectorInstrumentation::shouldPauseDedicatedWorkerOnStart(document))
         startMode = PauseWorkerGlobalScopeOnStart;
 
     // FIXME: this document's origin is pristine and without any extra privileges. (crbug.com/254993)
     SecurityOrigin* starterOrigin = document->securityOrigin();
 
     OwnPtrWillBeRawPtr<WorkerClients> workerClients = WorkerClients::create();
     provideLocalFileSystemToWorker(workerClients.get(), LocalFileSystemClient::create());
     WebSecurityOrigin webSecurityOrigin(m_loadingDocument->securityOrigin());
     provideContentSettingsClientToWorker(workerClients.get(), adoptPtr(m_client->createWorkerContentSettingsClientProxy(webSecurityOrigin)));
+    RefPtr<ContentSecurityPolicy> contentSecurityPolicy = m_mainScriptLoader->releaseContentSecurityPolicy();
     OwnPtr<WorkerThreadStartupData> startupData = WorkerThreadStartupData::create(
         m_url,
         m_loadingDocument->userAgent(m_url),
         m_mainScriptLoader->script(),
         nullptr,
         startMode,
-        m_mainScriptLoader->contentSecurityPolicy()->headers(),
+        contentSecurityPolicy ? contentSecurityPolicy->headers() : nullptr,
         starterOrigin,
         workerClients.release());
     m_loaderProxy = WorkerLoaderProxy::create(this);
     setWorkerThread(SharedWorkerThread::create(m_name, m_loaderProxy, *this));
     InspectorInstrumentation::scriptImported(m_loadingDocument.get(), m_mainScriptLoader->identifier(), m_mainScriptLoader->script());
     m_mainScriptLoader.clear();
 
     workerThread()->start(startupData.release());
     m_workerInspectorProxy->workerThreadCreated(m_loadingDocument.get(), workerThread(), m_url);
     m_client->workerScriptLoaded();
@@ skipping 39 matching lines @@
     if (devtoolsAgent)
         devtoolsAgent->dispatchOnInspectorBackend(message);
 }
 
 WebSharedWorker* WebSharedWorker::create(WebSharedWorkerClient* client)
 {
     return new WebSharedWorkerImpl(client);
 }
 
 } // namespace blink