Have WorkerScriptController::workerGlobalScope return a reference

Source/web/DatabaseObserver.cpp

 /*
  * Copyright (C) 2010 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 44 matching lines @@
 using namespace WebKit;
 
 namespace {
 
 static const char allowDatabaseMode[] = "allowDatabaseMode";
 
 // This class is used to route the result of the WebWorkerBase::allowDatabase
 // call back to the worker context.
 class AllowDatabaseMainThreadBridge : public WorkerAllowMainThreadBridgeBase {
 public:
-    static PassRefPtr<AllowDatabaseMainThreadBridge> create(WebCore::WorkerGlobalScope* workerGlobalScope, WebWorkerBase* webWorkerBase, const String& mode, WebFrame* frame, const String& name, const String& displayName, unsigned long estimatedSize)
+    static PassRefPtr<AllowDatabaseMainThreadBridge> create(WebCore::WorkerGlobalScope& workerGlobalScope, WebWorkerBase* webWorkerBase, const String& mode, WebFrame* frame, const String& name, const String& displayName, unsigned long estimatedSize)
     {
         return adoptRef(new AllowDatabaseMainThreadBridge(workerGlobalScope, webWorkerBase, mode, frame, name, displayName, estimatedSize));
     }
 
 private:
     class AllowDatabaseParams : public AllowParams
     {
     public:
         AllowDatabaseParams(const String& mode, WebFrame* frame, const String& name, const String& displayName, unsigned long estimatedSize)
             : AllowParams(mode)
             , m_frame(WebCore::AllowCrossThreadAccess(frame))
             , m_name(name.isolatedCopy())
             , m_displayName(displayName.isolatedCopy())
             , m_estimatedSize(estimatedSize)
         {
         }
         WebCore::AllowCrossThreadAccessWrapper<WebFrame> m_frame;
         String m_name;
         String m_displayName;
         unsigned long m_estimatedSize;
     };
 
-    AllowDatabaseMainThreadBridge(WebCore::WorkerGlobalScope* workerGlobalScope, WebWorkerBase* webWorkerBase, const String& mode, WebFrame* frame, const String& name, const String& displayName, unsigned long estimatedSize)
-        : WorkerAllowMainThreadBridgeBase(workerGlobalScope, webWorkerBase)
+    AllowDatabaseMainThreadBridge(WebCore::WorkerGlobalScope& workerGlobalScope, WebWorkerBase* webWorkerBase, const String& mode, WebFrame* frame, const String& name, const String& displayName, unsigned long estimatedSize)
+        : WorkerAllowMainThreadBridgeBase(&workerGlobalScope, webWorkerBase)
     {
         postTaskToMainThread(
             adoptPtr(new AllowDatabaseParams(mode, frame, name, displayName, estimatedSize)));
     }
 
     virtual bool allowOnMainThread(WebCommonWorkerClient* commonClient, AllowParams* params)
     {
         ASSERT(isMainThread());
         AllowDatabaseParams* allowDBParams = static_cast<AllowDatabaseParams*>(params);
         return commonClient->allowDatabase(
             allowDBParams->m_frame.value(), allowDBParams->m_name, allowDBParams->m_displayName, allowDBParams->m_estimatedSize);
     }
 };
 
 bool allowDatabaseForWorker(WebFrame* frame, const WebString& name, const WebString& displayName, unsigned long estimatedSize)
 {
     WebCore::WorkerScriptController* controller = WebCore::WorkerScriptController::controllerForContext();
-    WebCore::WorkerGlobalScope* workerGlobalScope = controller->workerGlobalScope();
-    WebCore::WorkerThread* workerThread = workerGlobalScope->thread();
+    WebCore::WorkerGlobalScope& workerGlobalScope = controller->workerGlobalScope();
+    WebCore::WorkerThread* workerThread = workerGlobalScope.thread();
     WebCore::WorkerRunLoop& runLoop = workerThread->runLoop();
     WebCore::WorkerLoaderProxy* workerLoaderProxy = &workerThread->workerLoaderProxy();
 
     // Create a unique mode just for this synchronous call.
     String mode = allowDatabaseMode;
     mode.append(String::number(runLoop.createUniqueId()));
 
     RefPtr<AllowDatabaseMainThreadBridge> bridge = AllowDatabaseMainThreadBridge::create(workerGlobalScope, workerLoaderProxy->toWebWorkerBase(), mode, frame, name, displayName, estimatedSize);
 
     // Either the bridge returns, or the queue gets terminated.
-    if (runLoop.runInMode(workerGlobalScope, mode) == MessageQueueTerminated) {
+    if (runLoop.runInMode(&workerGlobalScope, mode) == MessageQueueTerminated) {
         bridge->cancel();
         return false;
     }
 
     return bridge->result();
 }
 
 }
 
 namespace WebCore {
@@ skipping 66 matching lines @@
 {
     WebDatabase::observer()->reportExecuteStatementResult(WebDatabase(database), errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
 void DatabaseObserver::reportVacuumDatabaseResult(DatabaseBackendBase* database, int sqliteErrorCode)
 {
     WebDatabase::observer()->reportVacuumDatabaseResult(WebDatabase(database), sqliteErrorCode);
 }
 
 } // namespace WebCore