Introduce WebWorkerPermissionClientProxy to deprecate WorkerAllowMainThreadBridge

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 23 matching lines @@
 #include "WebCommonWorkerClient.h"
 #include "WebDatabase.h"
 #include "WebDatabaseObserver.h"
 #include "WebFrameClient.h"
 #include "WebFrameImpl.h"
 #include "WebPermissionClient.h"
 #include "WebSecurityOrigin.h"
 #include "WebViewImpl.h"
 #include "WebWorkerBase.h"
 #include "WorkerAllowMainThreadBridgeBase.h"
+#include "WorkerPermissionClient.h"
 #include "bindings/v8/WorkerScriptController.h"
 #include "core/dom/CrossThreadTask.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "modules/webdatabase/DatabaseBackendBase.h"
 #include "modules/webdatabase/DatabaseContext.h"
 #include "platform/CrossThreadCopier.h"
 
 using namespace WebKit;
 
 namespace {
 
 static const char allowDatabaseMode[] = "allowDatabaseMode";
 
+// FIXME: Deprecate this.
 // 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)
     {
         return adoptRef(new AllowDatabaseMainThreadBridge(workerGlobalScope, webWorkerBase, mode, frame, name, displayName, estimatedSize));
     }
 
 private:
@@ skipping 50 matching lines @@
         return false;
     }
 
     return bridge->result();
 }
 
 }
 
 namespace WebCore {
 
 bool DatabaseObserver::canEstablishDatabase(ExecutionContext* executionContext, const String& name, const String& displayName, unsigned long estimatedSize)

[abarth-chromium, 2013/10/30 06:49:03]

It's really lame that we have this WebCore symbol defined in the Source/web
directory.  This prevents us from splitting Source/web and Source/core into
separate DLLs.  We can leave this for now, but in a future refactoring, we might
want to make the permission client be defined in Source/core with virtual
functions and then have an "impl" object in Source/web, similar to how we handle
other "client" objects like WebFrameClient.

You don't need to worry about these issues in this CL, but I wanted to mention
it.

[kinuko, 2013/10/30 07:05:52]

Totally agreed about this class shouldn't be implemented like this.

 {
     ASSERT(executionContext->isContextThread());
     ASSERT(executionContext->isDocument() || executionContext->isWorkerGlobalScope());
     if (executionContext->isDocument()) {
         Document* document = toDocument(executionContext);
         WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame());
         if (!webFrame)
             return false;
         WebViewImpl* webView = webFrame->viewImpl();
         if (!webView)
             return false;
         if (webView->permissionClient())
             return webView->permissionClient()->allowDatabase(webFrame, name, displayName, estimatedSize);
     } else {
         WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(executionContext);
+        WorkerPermissionClient* permissionClient = WorkerPermissionClient::from(workerGlobalScope);
+        if (permissionClient->proxy())
+            return permissionClient->allowDatabase(name, displayName, estimatedSize);
+
+        // FIXME: Deprecate this bridge code when PermissionClientProxy is
+        // implemented by the embedder.
         WebWorkerBase* webWorker = static_cast<WebWorkerBase*>(workerGlobalScope->thread()->workerLoaderProxy().toWebWorkerBase());
         WebView* view = webWorker->view();
         if (!view)
             return false;
         return allowDatabaseForWorker(view->mainFrame(), name, displayName, estimatedSize);
     }
 
     return true;
 }
 
@@ skipping 39 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