WebInspectorProxy.h [plain text]
#pragma once
#include "APIObject.h"
#include "Attachment.h"
#include "DebuggableInfoData.h"
#include "MessageReceiver.h"
#include "WebInspectorUtilities.h"
#include <JavaScriptCore/InspectorFrontendChannel.h>
#include <WebCore/FloatRect.h>
#include <WebCore/InspectorClient.h>
#include <WebCore/InspectorFrontendClient.h>
#include <wtf/Forward.h>
#include <wtf/RefPtr.h>
#include <wtf/WeakPtr.h>
#include <wtf/text/WTFString.h>
#if PLATFORM(MAC)
#include "WKGeometry.h"
#include <WebCore/IntRect.h>
#include <wtf/HashMap.h>
#include <wtf/RetainPtr.h>
#include <wtf/RunLoop.h>
OBJC_CLASS NSURL;
OBJC_CLASS NSView;
OBJC_CLASS NSWindow;
OBJC_CLASS WKWebInspectorProxyObjCAdapter;
OBJC_CLASS WKInspectorViewController;
#elif PLATFORM(WIN)
#include "WebView.h"
#endif
namespace WebCore {
class CertificateInfo;
}
namespace API {
class InspectorClient;
}
namespace WebKit {
class WebFrameProxy;
class WebInspectorProxyClient;
class WebPageProxy;
class WebPreferences;
#if ENABLE(INSPECTOR_EXTENSIONS)
class WebInspectorUIExtensionControllerProxy;
#endif
enum class AttachmentSide {
Bottom,
Right,
Left,
};
class WebInspectorProxy
: public API::ObjectImpl<API::Object::Type::Inspector>
, public IPC::MessageReceiver
, public Inspector::FrontendChannel
, public CanMakeWeakPtr<WebInspectorProxy>
#if PLATFORM(WIN)
, public WebCore::WindowMessageListener
#endif
{
public:
static Ref<WebInspectorProxy> create(WebPageProxy& inspectedPage)
{
return adoptRef(*new WebInspectorProxy(inspectedPage));
}
explicit WebInspectorProxy(WebPageProxy&);
virtual ~WebInspectorProxy();
void invalidate();
API::InspectorClient& inspectorClient() { return *m_inspectorClient; }
void setInspectorClient(std::unique_ptr<API::InspectorClient>&&);
WebPageProxy* inspectedPage() const { return m_inspectedPage; }
WebPageProxy* inspectorPage() const { return m_inspectorPage; }
#if ENABLE(INSPECTOR_EXTENSIONS)
WebInspectorUIExtensionControllerProxy& extensionController() const { return *m_extensionController; }
#endif
bool isConnected() const { return !!m_inspectorPage; }
bool isVisible() const { return m_isVisible; }
bool isFront();
void connect();
void show();
void hide();
void close();
void closeForCrash();
void reopen();
void resetState();
void reset();
void updateForNewPageProcess(WebPageProxy&);
#if PLATFORM(MAC)
enum class InspectionTargetType { Local, Remote };
static RetainPtr<NSWindow> createFrontendWindow(NSRect savedWindowFrame, InspectionTargetType);
void didBecomeActive();
void updateInspectorWindowTitle() const;
void inspectedViewFrameDidChange(CGFloat = 0);
void windowFrameDidChange();
void windowFullScreenDidChange();
NSWindow *inspectorWindow() const { return m_inspectorWindow.get(); }
void closeFrontendPage();
void closeFrontendAfterInactivityTimerFired();
void attachmentViewDidChange(NSView *oldView, NSView *newView);
void attachmentWillMoveFromWindow(NSWindow *oldWindow);
void attachmentDidMoveToWindow(NSWindow *newWindow);
const WebCore::FloatRect& sheetRect() const { return m_sheetRect; }
#endif
#if PLATFORM(GTK)
GtkWidget* inspectorView() const { return m_inspectorView; };
void setClient(std::unique_ptr<WebInspectorProxyClient>&&);
#endif
void showConsole();
void showResources();
void showMainResourceForFrame(WebFrameProxy*);
void openURLExternally(const String& url);
AttachmentSide attachmentSide() const { return m_attachmentSide; }
bool isAttached() const { return m_isAttached; }
void attachRight();
void attachLeft();
void attachBottom();
void attach(AttachmentSide = AttachmentSide::Bottom);
void detach();
void setAttachedWindowHeight(unsigned);
void setAttachedWindowWidth(unsigned);
void setSheetRect(const WebCore::FloatRect&);
void startWindowDrag();
bool isProfilingPage() const { return m_isProfilingPage; }
void togglePageProfiling();
bool isElementSelectionActive() const { return m_elementSelectionActive; }
void toggleElementSelection();
bool isUnderTest() const { return m_underTest; }
void setDiagnosticLoggingAvailable(bool);
void browserExtensionsEnabled(HashMap<String, String>&&);
void browserExtensionsDisabled(HashSet<String>&&);
static String inspectorPageURL();
static String inspectorTestPageURL();
static String inspectorBaseURL();
static bool isMainOrTestInspectorPage(const URL&);
static DebuggableInfoData infoForLocalDebuggable();
static const unsigned minimumWindowWidth;
static const unsigned minimumWindowHeight;
static const unsigned initialWindowWidth;
static const unsigned initialWindowHeight;
void evaluateInFrontendForTesting(const String&);
private:
void createFrontendPage();
void closeFrontendPageAndWindow();
void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
void sendMessageToFrontend(const String& message) override;
ConnectionType connectionType() const override { return ConnectionType::Local; }
WebPageProxy* platformCreateFrontendPage();
void platformCreateFrontendWindow();
void platformCloseFrontendPageAndWindow();
void platformDidCloseForCrash();
void platformInvalidate();
void platformResetState();
void platformBringToFront();
void platformBringInspectedPageToFront();
void platformHide();
bool platformIsFront();
void platformAttachAvailabilityChanged(bool);
void platformSetForcedAppearance(WebCore::InspectorFrontendClient::Appearance);
void platformOpenURLExternally(const String&);
void platformInspectedURLChanged(const String&);
void platformShowCertificate(const WebCore::CertificateInfo&);
unsigned platformInspectedWindowHeight();
unsigned platformInspectedWindowWidth();
void platformAttach();
void platformDetach();
void platformSetAttachedWindowHeight(unsigned);
void platformSetAttachedWindowWidth(unsigned);
void platformSetSheetRect(const WebCore::FloatRect&);
void platformStartWindowDrag();
void platformSave(const String& filename, const String& content, bool base64Encoded, bool forceSaveAs);
void platformAppend(const String& filename, const String& content);
#if PLATFORM(MAC)
bool platformCanAttach(bool webProcessCanAttach);
#else
bool platformCanAttach(bool webProcessCanAttach) { return webProcessCanAttach; }
#endif
void openLocalInspectorFrontend(bool canAttach, bool underTest);
void setFrontendConnection(IPC::Attachment);
void sendMessageToBackend(const String&);
void frontendLoaded();
void didClose();
void bringToFront();
void bringInspectedPageToFront();
void attachAvailabilityChanged(bool);
void setForcedAppearance(WebCore::InspectorFrontendClient::Appearance);
void inspectedURLChanged(const String&);
void showCertificate(const WebCore::CertificateInfo&);
void elementSelectionChanged(bool);
void timelineRecordingChanged(bool);
void setDeveloperPreferenceOverride(WebCore::InspectorClient::DeveloperPreference, Optional<bool>);
void save(const String& filename, const String& content, bool base64Encoded, bool forceSaveAs);
void append(const String& filename, const String& content);
bool canAttach() const { return m_canAttach; }
bool shouldOpenAttached();
void open();
unsigned inspectionLevel() const;
WebPreferences& inspectorPagePreferences() const;
#if PLATFORM(MAC)
void applyForcedAppearance();
#endif
#if PLATFORM(GTK) || PLATFORM(WPE)
void updateInspectorWindowTitle() const;
#endif
#if PLATFORM(WIN)
static LRESULT CALLBACK wndProc(HWND, UINT, WPARAM, LPARAM);
bool registerWindowClass();
void windowReceivedMessage(HWND, UINT, WPARAM, LPARAM) override;
#endif
WebPageProxy* m_inspectedPage { nullptr };
WebPageProxy* m_inspectorPage { nullptr };
std::unique_ptr<API::InspectorClient> m_inspectorClient;
#if ENABLE(INSPECTOR_EXTENSIONS)
std::unique_ptr<WebInspectorUIExtensionControllerProxy> m_extensionController;
#endif
bool m_underTest { false };
bool m_isVisible { false };
bool m_isAttached { false };
bool m_canAttach { false };
bool m_isProfilingPage { false };
bool m_showMessageSent { false };
bool m_ignoreFirstBringToFront { false };
bool m_elementSelectionActive { false };
bool m_ignoreElementSelectionChange { false };
bool m_isActiveFrontend { false };
bool m_closing { false };
AttachmentSide m_attachmentSide {AttachmentSide::Bottom};
#if PLATFORM(MAC)
RetainPtr<WKInspectorViewController> m_inspectorViewController;
RetainPtr<NSWindow> m_inspectorWindow;
RetainPtr<WKWebInspectorProxyObjCAdapter> m_objCAdapter;
HashMap<String, RetainPtr<NSURL>> m_suggestedToActualURLMap;
RunLoop::Timer<WebInspectorProxy> m_closeFrontendAfterInactivityTimer;
String m_urlString;
WebCore::FloatRect m_sheetRect;
WebCore::InspectorFrontendClient::Appearance m_frontendAppearance { WebCore::InspectorFrontendClient::Appearance::System };
bool m_isObservingContentLayoutRect { false };
#elif PLATFORM(GTK)
std::unique_ptr<WebInspectorProxyClient> m_client;
GtkWidget* m_inspectorView { nullptr };
GtkWidget* m_inspectorWindow { nullptr };
GtkWidget* m_headerBar { nullptr };
String m_inspectedURLString;
bool m_isOpening { false };
#elif PLATFORM(WIN)
HWND m_inspectedViewWindow { nullptr };
HWND m_inspectedViewParentWindow { nullptr };
HWND m_inspectorViewWindow { nullptr };
HWND m_inspectorDetachWindow { nullptr };
RefPtr<WebView> m_inspectorView;
#endif
};
}