#include "config.h"
#include "EmptyClients.h"
#include "ColorChooser.h"
#include "DatabaseProvider.h"
#include "DocumentLoader.h"
#include "FileChooser.h"
#include "FormState.h"
#include "Frame.h"
#include "FrameNetworkingContext.h"
#include "HTMLFormElement.h"
#include "IDBFactoryBackendInterface.h"
#include "PageConfiguration.h"
#include "StorageArea.h"
#include "StorageNamespace.h"
#include "StorageNamespaceProvider.h"
#include <wtf/NeverDestroyed.h>
namespace WebCore {
class EmptyDatabaseProvider final : public DatabaseProvider {
#if ENABLE(INDEXED_DATABASE)
virtual RefPtr<IDBFactoryBackendInterface> createIDBFactoryBackend() { return nullptr; }
#endif
};
class EmptyStorageNamespaceProvider final : public StorageNamespaceProvider {
struct EmptyStorageArea : public StorageArea {
virtual unsigned length() override { return 0; }
virtual String key(unsigned) override { return String(); }
virtual String item(const String&) override { return String(); }
virtual void setItem(Frame*, const String&, const String&, bool&) override { }
virtual void removeItem(Frame*, const String&) override { }
virtual void clear(Frame*) override { }
virtual bool contains(const String&) override { return false; }
virtual bool canAccessStorage(Frame*) override { return false; }
virtual StorageType storageType() const override { return LocalStorage; }
virtual size_t memoryBytesUsedByCache() override { return 0; }
SecurityOrigin& securityOrigin() override { return SecurityOrigin::createUnique(); }
};
struct EmptyStorageNamespace final : public StorageNamespace {
virtual PassRefPtr<StorageArea> storageArea(PassRefPtr<SecurityOrigin>) override { return adoptRef(new EmptyStorageArea); }
virtual PassRefPtr<StorageNamespace> copy(Page*) override { return adoptRef(new EmptyStorageNamespace); }
};
virtual RefPtr<StorageNamespace> createSessionStorageNamespace(Page&, unsigned) override
{
return adoptRef(new EmptyStorageNamespace);
}
virtual RefPtr<StorageNamespace> createLocalStorageNamespace(unsigned) override
{
return adoptRef(new EmptyStorageNamespace);
}
virtual RefPtr<StorageNamespace> createTransientLocalStorageNamespace(SecurityOrigin&, unsigned) override
{
return adoptRef(new EmptyStorageNamespace);
}
};
class EmptyVisitedLinkStore : public VisitedLinkStore {
virtual bool isLinkVisited(Page&, LinkHash, const URL&, const AtomicString&) override { return false; }
virtual void addVisitedLink(Page&, LinkHash) override { }
};
void fillWithEmptyClients(PageConfiguration& pageConfiguration)
{
static NeverDestroyed<EmptyChromeClient> dummyChromeClient;
pageConfiguration.chromeClient = &dummyChromeClient.get();
#if ENABLE(CONTEXT_MENUS)
static NeverDestroyed<EmptyContextMenuClient> dummyContextMenuClient;
pageConfiguration.contextMenuClient = &dummyContextMenuClient.get();
#endif
#if ENABLE(DRAG_SUPPORT)
static NeverDestroyed<EmptyDragClient> dummyDragClient;
pageConfiguration.dragClient = &dummyDragClient.get();
#endif
static NeverDestroyed<EmptyEditorClient> dummyEditorClient;
pageConfiguration.editorClient = &dummyEditorClient.get();
static NeverDestroyed<EmptyInspectorClient> dummyInspectorClient;
pageConfiguration.inspectorClient = &dummyInspectorClient.get();
static NeverDestroyed<EmptyFrameLoaderClient> dummyFrameLoaderClient;
pageConfiguration.loaderClientForMainFrame = &dummyFrameLoaderClient.get();
static NeverDestroyed<EmptyProgressTrackerClient> dummyProgressTrackerClient;
pageConfiguration.progressTrackerClient = &dummyProgressTrackerClient.get();
static NeverDestroyed<EmptyDiagnosticLoggingClient> dummyDiagnosticLoggingClient;
pageConfiguration.diagnosticLoggingClient = &dummyDiagnosticLoggingClient.get();
pageConfiguration.databaseProvider = adoptRef(new EmptyDatabaseProvider);
pageConfiguration.storageNamespaceProvider = adoptRef(new EmptyStorageNamespaceProvider);
pageConfiguration.visitedLinkStore = adoptRef(new EmptyVisitedLinkStore);
}
class EmptyPopupMenu : public PopupMenu {
public:
virtual void show(const IntRect&, FrameView*, int) { }
virtual void hide() { }
virtual void updateFromElement() { }
virtual void disconnectClient() { }
};
class EmptySearchPopupMenu : public SearchPopupMenu {
public:
virtual PopupMenu* popupMenu() { return m_popup.get(); }
virtual void saveRecentSearches(const AtomicString&, const Vector<String>&) { }
virtual void loadRecentSearches(const AtomicString&, Vector<String>&) { }
virtual bool enabled() { return false; }
private:
RefPtr<EmptyPopupMenu> m_popup;
};
PassRefPtr<PopupMenu> EmptyChromeClient::createPopupMenu(PopupMenuClient*) const
{
return adoptRef(new EmptyPopupMenu());
}
PassRefPtr<SearchPopupMenu> EmptyChromeClient::createSearchPopupMenu(PopupMenuClient*) const
{
return adoptRef(new EmptySearchPopupMenu());
}
#if ENABLE(INPUT_TYPE_COLOR)
std::unique_ptr<ColorChooser> EmptyChromeClient::createColorChooser(ColorChooserClient*, const Color&)
{
return nullptr;
}
#endif
void EmptyChromeClient::runOpenPanel(Frame*, PassRefPtr<FileChooser>)
{
}
void EmptyFrameLoaderClient::dispatchDecidePolicyForNewWindowAction(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, const String&, FramePolicyFunction)
{
}
void EmptyFrameLoaderClient::dispatchDecidePolicyForNavigationAction(const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, FramePolicyFunction)
{
}
void EmptyFrameLoaderClient::dispatchWillSendSubmitEvent(PassRefPtr<FormState>)
{
}
void EmptyFrameLoaderClient::dispatchWillSubmitForm(PassRefPtr<FormState>, FramePolicyFunction)
{
}
PassRefPtr<DocumentLoader> EmptyFrameLoaderClient::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
{
return DocumentLoader::create(request, substituteData);
}
PassRefPtr<Frame> EmptyFrameLoaderClient::createFrame(const URL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int)
{
return 0;
}
PassRefPtr<Widget> EmptyFrameLoaderClient::createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool)
{
return 0;
}
void EmptyFrameLoaderClient::recreatePlugin(Widget*)
{
}
PassRefPtr<Widget> EmptyFrameLoaderClient::createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL&, const Vector<String>&, const Vector<String>&)
{
return 0;
}
PassRefPtr<FrameNetworkingContext> EmptyFrameLoaderClient::createNetworkingContext()
{
return PassRefPtr<FrameNetworkingContext>();
}
void EmptyTextCheckerClient::requestCheckingOfString(PassRefPtr<TextCheckingRequest>)
{
}
void EmptyEditorClient::registerUndoStep(PassRefPtr<UndoStep>)
{
}
void EmptyEditorClient::registerRedoStep(PassRefPtr<UndoStep>)
{
}
#if ENABLE(CONTEXT_MENUS)
#if USE(CROSS_PLATFORM_CONTEXT_MENUS)
std::unique_ptr<ContextMenu> EmptyContextMenuClient::customizeMenu(std::unique_ptr<ContextMenu>)
{
return nullptr;
}
#endif
#endif
}