Cleanup: Remove WeakPtr usage in WebSharedWorkerImpl

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 147 matching lines @@
             SecurityOrigin::create(KURL(ParsedURLString, "http://localhost"));
         origin.release();
     }
 }
 
 WebSharedWorkerImpl::WebSharedWorkerImpl(WebSharedWorkerClient* client)
     : m_webView(0)
     , m_mainFrame(0)
     , m_askedToTerminate(false)
     , m_workerInspectorProxy(WorkerInspectorProxy::create())
-    , m_client(WeakReference<WebSharedWorkerClient>::create(client))
-    , m_clientWeakPtr(WeakPtr<WebSharedWorkerClient>(m_client))
+    , m_client(client)
     , m_pauseWorkerContextOnStart(false)
     , m_isPausedOnStart(false)
 {
     initializeWebKitStaticValues();
 }
 
 WebSharedWorkerImpl::~WebSharedWorkerImpl()
 {
     ASSERT(m_webView);
     // Detach the client before closing the view to avoid getting called back.
     m_mainFrame->setClient(0);
 
     m_webView->close();
     m_mainFrame->close();
     if (m_loaderProxy)
         m_loaderProxy->detachProvider(this);
 }
 
 void WebSharedWorkerImpl::terminateWorkerThread()
 {
     if (m_askedToTerminate)
         return;
     m_askedToTerminate = true;
     if (m_mainScriptLoader) {
         m_mainScriptLoader->cancel();
         m_mainScriptLoader.clear();
-        if (client())
-            client()->workerScriptLoadFailed();
+        m_client->workerScriptLoadFailed();
         delete this;
         return;
     }
     if (m_workerThread)
         m_workerThread->terminate();
     m_workerInspectorProxy->workerThreadTerminated();
 }
 
 void WebSharedWorkerImpl::initializeLoader()
 {
     // Create 'shadow page'. This page is never displayed, it is used to proxy the
     // loading requests from the worker context to the rest of WebKit and Chromium
     // infrastructure.
     ASSERT(!m_webView);
     m_webView = WebView::create(0);
     // FIXME: http://crbug.com/363843. This needs to find a better way to
     // not create graphics layers.
     m_webView->settings()->setAcceleratedCompositingEnabled(false);
     // FIXME: Settings information should be passed to the Worker process from Browser process when the worker
     // is created (similar to RenderThread::OnCreateNewView).
     m_mainFrame = toWebLocalFrameImpl(WebLocalFrame::create(WebTreeScopeType::Document, this));
     m_webView->setMainFrame(m_mainFrame);
     m_mainFrame->setDevToolsAgentClient(this);
 
     // If we were asked to pause worker context on start and wait for debugger then it is the good time to do that.
-    client()->workerReadyForInspection();
+    m_client->workerReadyForInspection();
     if (m_pauseWorkerContextOnStart) {
         m_isPausedOnStart = true;
         return;
     }
     loadShadowPage();
 }
 
 WebApplicationCacheHost* WebSharedWorkerImpl::createApplicationCacheHost(WebLocalFrame*, WebApplicationCacheHostClient* appcacheHostClient)
 {
-    if (client())
-        return client()->createApplicationCacheHost(appcacheHostClient);
-    return 0;
+    return m_client->createApplicationCacheHost(appcacheHostClient);
 }
 
 void WebSharedWorkerImpl::loadShadowPage()
 {
     // Construct substitute data source for the 'shadow page'. We only need it
     // to have same origin as the worker so the loading checks work correctly.
     CString content("");
     RefPtr<SharedBuffer> buffer(SharedBuffer::create(content.data(), content.length()));
     m_mainFrame->frame()->loader().load(FrameLoadRequest(0, ResourceRequest(m_url), SubstituteData(buffer, "text/html", "UTF-8", KURL())));
 }
 
 void WebSharedWorkerImpl::willSendRequest(
     WebLocalFrame* frame, unsigned, WebURLRequest& request,
     const WebURLResponse& redirectResponse)
 {
     if (m_networkProvider)
         m_networkProvider->willSendRequest(frame->dataSource(), request);
 }
 
 void WebSharedWorkerImpl::didFinishDocumentLoad(WebLocalFrame* frame)
 {
     ASSERT(!m_loadingDocument);
     ASSERT(!m_mainScriptLoader);
-    m_networkProvider = adoptPtr(client()->createServiceWorkerNetworkProvider(frame->dataSource()));
+    m_networkProvider = adoptPtr(m_client->createServiceWorkerNetworkProvider(frame->dataSource()));
     m_mainScriptLoader = Loader::create();
     m_loadingDocument = toWebLocalFrameImpl(frame)->frame()->document();
     m_mainScriptLoader->load(
         m_loadingDocument.get(),
         m_url,
         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)
 {
     if (!m_networkProvider)
         return -1;
     return m_networkProvider->serviceWorkerID(dataSource);
 }
 
 void WebSharedWorkerImpl::sendProtocolMessage(int callId, const WebString& message, const WebString& state)
 {
-    client()->sendDevToolsMessage(callId, message, state);
+    m_client->sendDevToolsMessage(callId, message, state);
 }
 
 void WebSharedWorkerImpl::resumeStartup()
 {
     bool isPausedOnStart = m_isPausedOnStart;
     m_isPausedOnStart = false;
     if (isPausedOnStart)
         loadShadowPage();
 }
 
@@ skipping 23 matching lines @@
 
 }
 
 void WebSharedWorkerImpl::workerGlobalScopeClosed()
 {
     Platform::current()->mainThread()->postTask(FROM_HERE, threadSafeBind(&WebSharedWorkerImpl::workerGlobalScopeClosedOnMainThread, AllowCrossThreadAccess(this)));
 }
 
 void WebSharedWorkerImpl::workerGlobalScopeClosedOnMainThread()
 {
-    if (client())
-        client()->workerContextClosed();
+    m_client->workerContextClosed();
 
     terminateWorkerThread();
 }
 
 void WebSharedWorkerImpl::workerGlobalScopeStarted(WorkerGlobalScope*)
 {
 }
 
 void WebSharedWorkerImpl::workerThreadTerminated()
 {
     Platform::current()->mainThread()->postTask(FROM_HERE, threadSafeBind(&WebSharedWorkerImpl::workerThreadTerminatedOnMainThread, AllowCrossThreadAccess(this)));
 }
 
 void WebSharedWorkerImpl::workerThreadTerminatedOnMainThread()
 {
-    if (client())
-        client()->workerContextDestroyed();
+    m_client->workerContextDestroyed();
     // The lifetime of this proxy is controlled by the worker context.
     delete this;
 }
 
 // WorkerLoaderProxyProvider -----------------------------------------------------------
 
 void WebSharedWorkerImpl::postTaskToLoader(PassOwnPtr<ExecutionContextTask> task)
 {
     m_mainFrame->frame()->document()->postTask(FROM_HERE, task);
 }
@@ skipping 23 matching lines @@
 void WebSharedWorkerImpl::startWorkerContext(const WebURL& url, const WebString& name, const WebString& contentSecurityPolicy, WebContentSecurityPolicyType policyType)
 {
     m_url = url;
     m_name = name;
     initializeLoader();
 }
 
 void WebSharedWorkerImpl::didReceiveScriptLoaderResponse()
 {
     InspectorInstrumentation::didReceiveScriptResponse(m_loadingDocument.get(), m_mainScriptLoader->identifier());
-    if (client())
-        client()->selectAppCacheID(m_mainScriptLoader->appCacheID());
+    m_client->selectAppCacheID(m_mainScriptLoader->appCacheID());
 }
 
 void WebSharedWorkerImpl::onScriptLoaderFinished()
 {
     ASSERT(m_loadingDocument);
     ASSERT(m_mainScriptLoader);
     if (m_askedToTerminate)
         return;
     if (m_mainScriptLoader->failed()) {
         m_mainScriptLoader->cancel();
-        if (client())
-            client()->workerScriptLoadFailed();
+        m_client->workerScriptLoadFailed();
 
         // The SharedWorker was unable to load the initial script, so
         // shut it down right here.
         delete this;
         return;
     }
 
     Document* document = m_mainFrame->frame()->document();
     WorkerThreadStartMode startMode = DontPauseWorkerGlobalScopeOnStart;
     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(client()->createWorkerContentSettingsClientProxy(webSecurityOrigin)));
+    provideContentSettingsClientToWorker(workerClients.get(), adoptPtr(m_client->createWorkerContentSettingsClientProxy(webSecurityOrigin)));
     OwnPtr<WorkerThreadStartupData> startupData = WorkerThreadStartupData::create(m_url, m_loadingDocument->userAgent(m_url), m_mainScriptLoader->script(), nullptr, startMode, m_mainScriptLoader->contentSecurityPolicy()->headers(), 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);
-    if (client())
-        client()->workerScriptLoaded();
+    m_client->workerScriptLoaded();
 }
 
 void WebSharedWorkerImpl::terminateWorkerContext()
 {
     terminateWorkerThread();
 }
 
-void WebSharedWorkerImpl::clientDestroyed()
-{
-    m_client.clear();
-}
-
 void WebSharedWorkerImpl::pauseWorkerContextOnStart()
 {
     m_pauseWorkerContextOnStart = true;
 }
 
 void WebSharedWorkerImpl::attachDevTools(const WebString& hostId)
 {
     WebDevToolsAgent* devtoolsAgent = m_mainFrame->devToolsAgent();
     if (devtoolsAgent)
         devtoolsAgent->attach(hostId);
@@ skipping 22 matching lines @@
     if (devtoolsAgent)
         devtoolsAgent->dispatchOnInspectorBackend(message);
 }
 
 WebSharedWorker* WebSharedWorker::create(WebSharedWorkerClient* client)
 {
     return new WebSharedWorkerImpl(client);
 }
 
 } // namespace blink