Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(676)

Unified Diff: third_party/WebKit/Source/web/InspectorOverlayAgent.cpp

Issue 2819183002: [DevTools] Consolidate overlay-related functionality in Overlay domain (Closed)
Patch Set: rebased bad merge Created 3 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: third_party/WebKit/Source/web/InspectorOverlayAgent.cpp
diff --git a/third_party/WebKit/Source/web/InspectorOverlay.cpp b/third_party/WebKit/Source/web/InspectorOverlayAgent.cpp
similarity index 57%
rename from third_party/WebKit/Source/web/InspectorOverlay.cpp
rename to third_party/WebKit/Source/web/InspectorOverlayAgent.cpp
index 850d2831fd8e1b23406e069122179f472a6e8bae..e5ad62dc885af4993741a082418efa89e6a91cf3 100644
--- a/third_party/WebKit/Source/web/InspectorOverlay.cpp
+++ b/third_party/WebKit/Source/web/InspectorOverlayAgent.cpp
@@ -26,7 +26,7 @@
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "web/InspectorOverlay.h"
+#include "web/InspectorOverlayAgent.h"
#include <memory>
@@ -34,6 +34,7 @@
#include "bindings/core/v8/ScriptSourceCode.h"
#include "bindings/core/v8/V8Binding.h"
#include "bindings/core/v8/V8InspectorOverlayHost.h"
+#include "core/dom/DOMNodeIds.h"
#include "core/dom/Node.h"
#include "core/dom/StaticNodeList.h"
#include "core/dom/TaskRunnerHelper.h"
@@ -44,6 +45,9 @@
#include "core/frame/VisualViewport.h"
#include "core/html/HTMLFrameOwnerElement.h"
#include "core/input/EventHandler.h"
+#include "core/inspector/IdentifiersFactory.h"
+#include "core/inspector/InspectedFrames.h"
+#include "core/inspector/InspectorDOMAgent.h"
#include "core/inspector/InspectorOverlayHost.h"
#include "core/layout/api/LayoutViewItem.h"
#include "core/loader/EmptyClients.h"
@@ -62,11 +66,26 @@
#include "web/PageOverlay.h"
#include "web/WebInputEventConversion.h"
#include "web/WebLocalFrameImpl.h"
+#include "web/WebViewImpl.h"
namespace blink {
+using protocol::Maybe;
+using protocol::Response;
+
namespace {
+namespace OverlayAgentState {
+static const char kEnabled[] = "enabled";
+static const char kShowDebugBorders[] = "showDebugBorders";
+static const char kShowFPSCounter[] = "showFPSCounter";
+static const char kShowPaintRects[] = "showPaintRects";
+static const char kShowScrollBottleneckRects[] = "showScrollBottleneckRects";
+static const char kShowSizeOnResize[] = "showSizeOnResize";
+static const char kSuspended[] = "suspended";
+static const char kPausedInDebuggerMessage[] = "pausedInDebuggerMessage";
+}
+
Node* HoveredNodeForPoint(LocalFrame* frame,
const IntPoint& point_in_root_frame,
bool ignore_pointer_events_none) {
@@ -110,12 +129,25 @@ Node* HoveredNodeForEvent(LocalFrame* frame,
return HoveredNodeForPoint(frame, RoundedIntPoint(transformed_point.position),
ignore_pointer_events_none);
}
+
+bool ParseQuad(std::unique_ptr<protocol::Array<double>> quad_array,
+ FloatQuad* quad) {
+ const size_t kCoordinatesInQuad = 8;
+ if (!quad_array || quad_array->length() != kCoordinatesInQuad)
+ return false;
+ quad->SetP1(FloatPoint(quad_array->get(0), quad_array->get(1)));
+ quad->SetP2(FloatPoint(quad_array->get(2), quad_array->get(3)));
+ quad->SetP3(FloatPoint(quad_array->get(4), quad_array->get(5)));
+ quad->SetP4(FloatPoint(quad_array->get(6), quad_array->get(7)));
+ return true;
+}
+
} // namespace
-class InspectorOverlay::InspectorPageOverlayDelegate final
+class InspectorOverlayAgent::InspectorPageOverlayDelegate final
: public PageOverlay::Delegate {
public:
- explicit InspectorPageOverlayDelegate(InspectorOverlay& overlay)
+ explicit InspectorPageOverlayDelegate(InspectorOverlayAgent& overlay)
: overlay_(&overlay) {}
void PaintPageOverlay(const PageOverlay&,
@@ -131,14 +163,14 @@ class InspectorOverlay::InspectorPageOverlayDelegate final
}
private:
- Persistent<InspectorOverlay> overlay_;
+ Persistent<InspectorOverlayAgent> overlay_;
};
-class InspectorOverlay::InspectorOverlayChromeClient final
+class InspectorOverlayAgent::InspectorOverlayChromeClient final
: public EmptyChromeClient {
public:
static InspectorOverlayChromeClient* Create(ChromeClient& client,
- InspectorOverlay& overlay) {
+ InspectorOverlayAgent& overlay) {
return new InspectorOverlayChromeClient(client, overlay);
}
@@ -172,36 +204,47 @@ class InspectorOverlay::InspectorOverlayChromeClient final
}
private:
- InspectorOverlayChromeClient(ChromeClient& client, InspectorOverlay& overlay)
+ InspectorOverlayChromeClient(ChromeClient& client,
+ InspectorOverlayAgent& overlay)
: client_(&client), overlay_(&overlay) {}
Member<ChromeClient> client_;
- Member<InspectorOverlay> overlay_;
+ Member<InspectorOverlayAgent> overlay_;
};
-InspectorOverlay::InspectorOverlay(WebLocalFrameImpl* frame_impl)
+InspectorOverlayAgent::InspectorOverlayAgent(
+ WebLocalFrameImpl* frame_impl,
+ InspectedFrames* inspected_frames,
+ v8_inspector::V8InspectorSession* v8_session,
+ InspectorDOMAgent* dom_agent)
: frame_impl_(frame_impl),
- overlay_host_(InspectorOverlayHost::Create()),
+ inspected_frames_(inspected_frames),
+ enabled_(false),
+ overlay_host_(new InspectorOverlayHost(this)),
draw_view_size_(false),
resize_timer_active_(false),
omit_tooltip_(false),
timer_(TaskRunnerHelper::Get(TaskType::kUnspecedTimer,
frame_impl->GetFrame()),
this,
- &InspectorOverlay::OnTimer),
+ &InspectorOverlayAgent::OnTimer),
suspended_(false),
show_reloading_blanket_(false),
in_layout_(false),
needs_update_(false),
+ v8_session_(v8_session),
+ dom_agent_(dom_agent),
swallow_next_mouse_up_(false),
- inspect_mode_(InspectorDOMAgent::kNotSearching) {}
+ inspect_mode_(kNotSearching),
+ backend_node_id_to_inspect_(0) {}
-InspectorOverlay::~InspectorOverlay() {
+InspectorOverlayAgent::~InspectorOverlayAgent() {
DCHECK(!overlay_page_);
}
-DEFINE_TRACE(InspectorOverlay) {
+DEFINE_TRACE(InspectorOverlayAgent) {
visitor->Trace(frame_impl_);
+ visitor->Trace(inspected_frames_);
visitor->Trace(highlight_node_);
visitor->Trace(event_target_node_);
visitor->Trace(overlay_page_);
@@ -209,16 +252,252 @@ DEFINE_TRACE(InspectorOverlay) {
visitor->Trace(overlay_host_);
visitor->Trace(dom_agent_);
visitor->Trace(hovered_node_for_inspect_mode_);
+ InspectorBaseAgent::Trace(visitor);
+}
+
+void InspectorOverlayAgent::Restore() {
+ if (state_->booleanProperty(OverlayAgentState::kEnabled, false))
+ enabled_ = true;
+ setShowDebugBorders(
+ state_->booleanProperty(OverlayAgentState::kShowDebugBorders, false));
+ setShowFPSCounter(
+ state_->booleanProperty(OverlayAgentState::kShowFPSCounter, false));
+ setShowPaintRects(
+ state_->booleanProperty(OverlayAgentState::kShowPaintRects, false));
+ setShowScrollBottleneckRects(state_->booleanProperty(
+ OverlayAgentState::kShowScrollBottleneckRects, false));
+ setShowViewportSizeOnResize(
+ state_->booleanProperty(OverlayAgentState::kShowSizeOnResize, false));
+ String message;
+ state_->getString(OverlayAgentState::kPausedInDebuggerMessage, &message);
+ setPausedInDebuggerMessage(message);
+ setSuspended(state_->booleanProperty(OverlayAgentState::kSuspended, false));
+}
+
+void InspectorOverlayAgent::Dispose() {
+ show_reloading_blanket_ = false;
+ ClearInternal();
+ InspectorBaseAgent::Dispose();
+}
+
+Response InspectorOverlayAgent::enable() {
+ if (!dom_agent_->Enabled())
+ return Response::Error("DOM should be enabled first");
+ state_->setBoolean(OverlayAgentState::kEnabled, true);
+ enabled_ = true;
+ if (backend_node_id_to_inspect_)
+ GetFrontend()->inspectNodeRequested(backend_node_id_to_inspect_);
+ backend_node_id_to_inspect_ = 0;
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::disable() {
+ state_->setBoolean(OverlayAgentState::kEnabled, false);
+ enabled_ = false;
+ setShowDebugBorders(false);
+ setShowFPSCounter(false);
+ setShowPaintRects(false);
+ setShowScrollBottleneckRects(false);
+ setShowViewportSizeOnResize(false);
+ setPausedInDebuggerMessage(String());
+ setSuspended(false);
+ SetSearchingForNode(kNotSearching,
+ Maybe<protocol::Overlay::HighlightConfig>());
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::setShowDebugBorders(bool show) {
+ state_->setBoolean(OverlayAgentState::kShowDebugBorders, show);
+ if (show) {
+ Response response = CompositingEnabled();
+ if (!response.isSuccess())
+ return response;
+ }
+ frame_impl_->ViewImpl()->SetShowDebugBorders(show);
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::setShowFPSCounter(bool show) {
+ state_->setBoolean(OverlayAgentState::kShowFPSCounter, show);
+ if (show) {
+ Response response = CompositingEnabled();
+ if (!response.isSuccess())
+ return response;
+ }
+ frame_impl_->ViewImpl()->SetShowFPSCounter(show);
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::setShowPaintRects(bool show) {
+ state_->setBoolean(OverlayAgentState::kShowPaintRects, show);
+ if (show) {
+ Response response = CompositingEnabled();
+ if (!response.isSuccess())
+ return response;
+ }
+ frame_impl_->ViewImpl()->SetShowPaintRects(show);
+ if (!show && frame_impl_->GetFrameView())
+ frame_impl_->GetFrameView()->Invalidate();
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::setShowScrollBottleneckRects(bool show) {
+ state_->setBoolean(OverlayAgentState::kShowScrollBottleneckRects, show);
+ if (show) {
+ Response response = CompositingEnabled();
+ if (!response.isSuccess())
+ return response;
+ }
+ frame_impl_->ViewImpl()->SetShowScrollBottleneckRects(show);
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::setShowViewportSizeOnResize(bool show) {
+ state_->setBoolean(OverlayAgentState::kShowSizeOnResize, show);
+ draw_view_size_ = show;
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::setPausedInDebuggerMessage(
+ Maybe<String> message) {
+ String just_message = message.fromMaybe(String());
+ state_->setString(OverlayAgentState::kPausedInDebuggerMessage, just_message);
+ paused_in_debugger_message_ = just_message;
+ ScheduleUpdate();
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::setSuspended(bool suspended) {
+ state_->setBoolean(OverlayAgentState::kSuspended, suspended);
+ if (suspended && !suspended_ && !show_reloading_blanket_)
+ ClearInternal();
+ suspended_ = suspended;
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::setInspectMode(
+ const String& mode,
+ Maybe<protocol::Overlay::HighlightConfig> highlight_config) {
+ SearchMode search_mode;
+ if (mode == protocol::Overlay::InspectModeEnum::SearchForNode) {
+ search_mode = kSearchingForNormal;
+ } else if (mode == protocol::Overlay::InspectModeEnum::SearchForUAShadowDOM) {
+ search_mode = kSearchingForUAShadow;
+ } else if (mode == protocol::Overlay::InspectModeEnum::None) {
+ search_mode = kNotSearching;
+ } else {
+ return Response::Error(
+ String("Unknown mode \"" + mode + "\" was provided."));
+ }
+
+ if (search_mode != kNotSearching) {
+ Response response = dom_agent_->PushDocumentUponHandlelessOperation();
+ if (!response.isSuccess())
+ return response;
+ }
+
+ return SetSearchingForNode(search_mode, std::move(highlight_config));
+}
+
+Response InspectorOverlayAgent::highlightRect(
+ int x,
+ int y,
+ int width,
+ int height,
+ Maybe<protocol::DOM::RGBA> color,
+ Maybe<protocol::DOM::RGBA> outline_color) {
+ std::unique_ptr<FloatQuad> quad =
+ WTF::WrapUnique(new FloatQuad(FloatRect(x, y, width, height)));
+ InnerHighlightQuad(std::move(quad), std::move(color),
+ std::move(outline_color));
+ return Response::OK();
}
-void InspectorOverlay::Init(v8_inspector::V8InspectorSession* v8_session,
- InspectorDOMAgent* dom_agent) {
- v8_session_ = v8_session;
- dom_agent_ = dom_agent;
- overlay_host_->SetListener(this);
+Response InspectorOverlayAgent::highlightQuad(
+ std::unique_ptr<protocol::Array<double>> quad_array,
+ Maybe<protocol::DOM::RGBA> color,
+ Maybe<protocol::DOM::RGBA> outline_color) {
+ std::unique_ptr<FloatQuad> quad = WTF::MakeUnique<FloatQuad>();
+ if (!ParseQuad(std::move(quad_array), quad.get()))
+ return Response::Error("Invalid Quad format");
+ InnerHighlightQuad(std::move(quad), std::move(color),
+ std::move(outline_color));
+ return Response::OK();
}
-void InspectorOverlay::Invalidate() {
+Response InspectorOverlayAgent::highlightNode(
+ std::unique_ptr<protocol::Overlay::HighlightConfig>
+ highlight_inspector_object,
+ Maybe<int> node_id,
+ Maybe<int> backend_node_id,
+ Maybe<String> object_id) {
+ Node* node = nullptr;
+ Response response;
+ if (node_id.isJust()) {
+ response = dom_agent_->AssertNode(node_id.fromJust(), node);
+ } else if (backend_node_id.isJust()) {
+ node = DOMNodeIds::NodeForId(backend_node_id.fromJust());
+ response = !node ? Response::Error("No node found for given backend id")
+ : Response::OK();
+ } else if (object_id.isJust()) {
+ response = dom_agent_->NodeForRemoteObjectId(object_id.fromJust(), node);
+ } else {
+ response = Response::Error(
+ "Either nodeId, backendNodeId or objectId must be specified");
+ }
+
+ if (!response.isSuccess())
+ return response;
+
+ std::unique_ptr<InspectorHighlightConfig> highlight_config;
+ response = HighlightConfigFromInspectorObject(
+ std::move(highlight_inspector_object), &highlight_config);
+ if (!response.isSuccess())
+ return response;
+
+ InnerHighlightNode(node, nullptr, *highlight_config, false);
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::highlightFrame(
+ const String& frame_id,
+ Maybe<protocol::DOM::RGBA> color,
+ Maybe<protocol::DOM::RGBA> outline_color) {
+ LocalFrame* frame =
+ IdentifiersFactory::FrameById(inspected_frames_, frame_id);
+ // FIXME: Inspector doesn't currently work cross process.
+ if (frame && frame->DeprecatedLocalOwner()) {
+ std::unique_ptr<InspectorHighlightConfig> highlight_config =
+ WTF::MakeUnique<InspectorHighlightConfig>();
+ highlight_config->show_info = true; // Always show tooltips for frames.
+ highlight_config->content =
+ InspectorDOMAgent::ParseColor(color.fromMaybe(nullptr));
+ highlight_config->content_outline =
+ InspectorDOMAgent::ParseColor(outline_color.fromMaybe(nullptr));
+ InnerHighlightNode(frame->DeprecatedLocalOwner(), nullptr,
+ *highlight_config, false);
+ }
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::hideHighlight() {
+ InnerHideHighlight();
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::getHighlightObjectForTest(
+ int node_id,
+ std::unique_ptr<protocol::DictionaryValue>* result) {
+ Node* node = nullptr;
+ Response response = dom_agent_->AssertNode(node_id, node);
+ if (!response.isSuccess())
+ return response;
+ InspectorHighlight highlight(node, InspectorHighlight::DefaultConfig(), true);
+ *result = highlight.AsProtocolValue();
+ return Response::OK();
+}
+
+void InspectorOverlayAgent::Invalidate() {
if (!page_overlay_) {
page_overlay_ = PageOverlay::Create(
frame_impl_, WTF::WrapUnique(new InspectorPageOverlayDelegate(*this)));
@@ -227,7 +506,7 @@ void InspectorOverlay::Invalidate() {
page_overlay_->Update();
}
-void InspectorOverlay::UpdateAllLifecyclePhases() {
+void InspectorOverlayAgent::UpdateAllLifecyclePhases() {
if (IsEmpty())
return;
@@ -239,7 +518,7 @@ void InspectorOverlay::UpdateAllLifecyclePhases() {
OverlayMainFrame()->View()->UpdateAllLifecyclePhases();
}
-bool InspectorOverlay::HandleInputEvent(const WebInputEvent& input_event) {
+bool InspectorOverlayAgent::HandleInputEvent(const WebInputEvent& input_event) {
bool handled = false;
if (IsEmpty())
@@ -278,12 +557,14 @@ bool InspectorOverlay::HandleInputEvent(const WebInputEvent& input_event) {
std::vector<const WebInputEvent*>())) !=
WebInputEventResult::kNotHandled;
}
- if (mouse_event.GetType() == WebInputEvent::kMouseDown)
+ if (mouse_event.GetType() == WebInputEvent::kMouseDown) {
handled = OverlayMainFrame()->GetEventHandler().HandleMousePressEvent(
mouse_event) != WebInputEventResult::kNotHandled;
- if (mouse_event.GetType() == WebInputEvent::kMouseUp)
+ }
+ if (mouse_event.GetType() == WebInputEvent::kMouseUp) {
handled = OverlayMainFrame()->GetEventHandler().HandleMouseReleaseEvent(
mouse_event) != WebInputEventResult::kNotHandled;
+ }
}
if (WebInputEvent::IsTouchEventType(input_event.GetType())) {
@@ -312,17 +593,12 @@ bool InspectorOverlay::HandleInputEvent(const WebInputEvent& input_event) {
return handled;
}
-void InspectorOverlay::SetPausedInDebuggerMessage(const String& message) {
- paused_in_debugger_message_ = message;
- ScheduleUpdate();
-}
-
-void InspectorOverlay::ShowReloadingBlanket() {
+void InspectorOverlayAgent::ShowReloadingBlanket() {
show_reloading_blanket_ = true;
ScheduleUpdate();
}
-void InspectorOverlay::HideReloadingBlanket() {
+void InspectorOverlayAgent::HideReloadingBlanket() {
if (!show_reloading_blanket_)
return;
show_reloading_blanket_ = false;
@@ -332,21 +608,14 @@ void InspectorOverlay::HideReloadingBlanket() {
ScheduleUpdate();
}
-void InspectorOverlay::HideHighlight() {
+void InspectorOverlayAgent::InnerHideHighlight() {
highlight_node_.Clear();
event_target_node_.Clear();
highlight_quad_.reset();
ScheduleUpdate();
}
-void InspectorOverlay::HighlightNode(
- Node* node,
- const InspectorHighlightConfig& highlight_config,
- bool omit_tooltip) {
- HighlightNode(node, nullptr, highlight_config, omit_tooltip);
-}
-
-void InspectorOverlay::HighlightNode(
+void InspectorOverlayAgent::InnerHighlightNode(
Node* node,
Node* event_target,
const InspectorHighlightConfig& highlight_config,
@@ -358,30 +627,19 @@ void InspectorOverlay::HighlightNode(
ScheduleUpdate();
}
-void InspectorOverlay::SetInspectMode(
- InspectorDOMAgent::SearchMode search_mode,
- std::unique_ptr<InspectorHighlightConfig> highlight_config) {
- inspect_mode_ = search_mode;
- ScheduleUpdate();
-
- if (search_mode != InspectorDOMAgent::kNotSearching) {
- inspect_mode_highlight_config_ = std::move(highlight_config);
- } else {
- hovered_node_for_inspect_mode_.Clear();
- HideHighlight();
- }
-}
-
-void InspectorOverlay::HighlightQuad(
+void InspectorOverlayAgent::InnerHighlightQuad(
std::unique_ptr<FloatQuad> quad,
- const InspectorHighlightConfig& highlight_config) {
- quad_highlight_config_ = highlight_config;
+ Maybe<protocol::DOM::RGBA> color,
+ Maybe<protocol::DOM::RGBA> outline_color) {
+ quad_content_color_ = InspectorDOMAgent::ParseColor(color.fromMaybe(nullptr));
+ quad_content_outline_color_ =
+ InspectorDOMAgent::ParseColor(outline_color.fromMaybe(nullptr));
highlight_quad_ = std::move(quad);
omit_tooltip_ = false;
ScheduleUpdate();
}
-bool InspectorOverlay::IsEmpty() {
+bool InspectorOverlayAgent::IsEmpty() {
if (show_reloading_blanket_)
return false;
if (suspended_)
@@ -390,11 +648,10 @@ bool InspectorOverlay::IsEmpty() {
highlight_quad_ ||
(resize_timer_active_ && draw_view_size_) ||
!paused_in_debugger_message_.IsNull();
- return !has_visible_elements &&
- inspect_mode_ == InspectorDOMAgent::kNotSearching;
+ return !has_visible_elements && inspect_mode_ == kNotSearching;
}
-void InspectorOverlay::ScheduleUpdate() {
+void InspectorOverlayAgent::ScheduleUpdate() {
if (IsEmpty()) {
if (page_overlay_)
page_overlay_.reset();
@@ -407,7 +664,7 @@ void InspectorOverlay::ScheduleUpdate() {
}
}
-void InspectorOverlay::RebuildOverlayPage() {
+void InspectorOverlayAgent::RebuildOverlayPage() {
FrameView* view = frame_impl_->GetFrameView();
LocalFrame* frame = frame_impl_->GetFrame();
if (!view || !frame)
@@ -441,7 +698,7 @@ static std::unique_ptr<protocol::DictionaryValue> BuildObjectForSize(
return result;
}
-void InspectorOverlay::DrawNodeHighlight() {
+void InspectorOverlayAgent::DrawNodeHighlight() {
if (!highlight_node_)
return;
@@ -451,9 +708,10 @@ void InspectorOverlay::DrawNodeHighlight() {
ContainerNode* query_base = highlight_node_->ContainingShadowRoot();
if (!query_base)
query_base = highlight_node_->ownerDocument();
- if (selectors.length())
+ if (selectors.length()) {
elements =
query_base->QuerySelectorAll(AtomicString(selectors), exception_state);
+ }
if (elements && !exception_state.HadException()) {
for (unsigned i = 0; i < elements->length(); ++i) {
Element* element = elements->item(i);
@@ -470,45 +728,46 @@ void InspectorOverlay::DrawNodeHighlight() {
highlight_node_->GetDocument().GetFrame();
InspectorHighlight highlight(highlight_node_.Get(), node_highlight_config_,
append_element_info);
- if (event_target_node_)
+ if (event_target_node_) {
highlight.AppendEventTargetQuads(event_target_node_.Get(),
node_highlight_config_);
+ }
std::unique_ptr<protocol::DictionaryValue> highlight_json =
highlight.AsProtocolValue();
EvaluateInOverlay("drawHighlight", std::move(highlight_json));
}
-void InspectorOverlay::DrawQuadHighlight() {
+void InspectorOverlayAgent::DrawQuadHighlight() {
if (!highlight_quad_)
return;
InspectorHighlight highlight(WindowToViewportScale());
- highlight.AppendQuad(*highlight_quad_, quad_highlight_config_.content,
- quad_highlight_config_.content_outline);
+ highlight.AppendQuad(*highlight_quad_, quad_content_color_,
+ quad_content_outline_color_);
EvaluateInOverlay("drawHighlight", highlight.AsProtocolValue());
}
-void InspectorOverlay::DrawPausedInDebuggerMessage() {
- if (inspect_mode_ == InspectorDOMAgent::kNotSearching &&
- !paused_in_debugger_message_.IsNull())
+void InspectorOverlayAgent::DrawPausedInDebuggerMessage() {
+ if (inspect_mode_ == kNotSearching && !paused_in_debugger_message_.IsNull()) {
EvaluateInOverlay("drawPausedInDebuggerMessage",
paused_in_debugger_message_);
+ }
}
-void InspectorOverlay::DrawViewSize() {
+void InspectorOverlayAgent::DrawViewSize() {
if (resize_timer_active_ && draw_view_size_)
EvaluateInOverlay("drawViewSize", "");
}
-float InspectorOverlay::WindowToViewportScale() const {
+float InspectorOverlayAgent::WindowToViewportScale() const {
LocalFrame* frame = frame_impl_->GetFrame();
if (!frame)
return 1.0f;
return frame->GetPage()->GetChromeClient().WindowToViewportScalar(1.0f);
}
-Page* InspectorOverlay::OverlayPage() {
+Page* InspectorOverlayAgent::OverlayPage() {
if (overlay_page_)
return overlay_page_.Get();
@@ -588,12 +847,12 @@ Page* InspectorOverlay::OverlayPage() {
return overlay_page_.Get();
}
-LocalFrame* InspectorOverlay::OverlayMainFrame() {
+LocalFrame* InspectorOverlayAgent::OverlayMainFrame() {
return ToLocalFrame(OverlayPage()->MainFrame());
}
-void InspectorOverlay::Reset(const IntSize& viewport_size,
- const IntPoint& document_scroll_offset) {
+void InspectorOverlayAgent::Reset(const IntSize& viewport_size,
+ const IntPoint& document_scroll_offset) {
std::unique_ptr<protocol::DictionaryValue> reset_data =
protocol::DictionaryValue::create();
reset_data->setDouble(
@@ -620,8 +879,8 @@ void InspectorOverlay::Reset(const IntSize& viewport_size,
EvaluateInOverlay("reset", std::move(reset_data));
}
-void InspectorOverlay::EvaluateInOverlay(const String& method,
- const String& argument) {
+void InspectorOverlayAgent::EvaluateInOverlay(const String& method,
+ const String& argument) {
ScriptForbiddenScope::AllowUserAgentScript allow_script;
std::unique_ptr<protocol::ListValue> command = protocol::ListValue::create();
command->pushValue(protocol::StringValue::create(method));
@@ -633,7 +892,7 @@ void InspectorOverlay::EvaluateInOverlay(const String& method,
ScriptController::kExecuteScriptWhenScriptsDisabled);
}
-void InspectorOverlay::EvaluateInOverlay(
+void InspectorOverlayAgent::EvaluateInOverlay(
const String& method,
std::unique_ptr<protocol::Value> argument) {
ScriptForbiddenScope::AllowUserAgentScript allow_script;
@@ -647,7 +906,7 @@ void InspectorOverlay::EvaluateInOverlay(
ScriptController::kExecuteScriptWhenScriptsDisabled);
}
-String InspectorOverlay::EvaluateInOverlayForTest(const String& script) {
+String InspectorOverlayAgent::EvaluateInOverlayForTest(const String& script) {
ScriptForbiddenScope::AllowUserAgentScript allow_script;
v8::HandleScope handle_scope(ToIsolate(OverlayMainFrame()));
v8::Local<v8::Value> string =
@@ -659,12 +918,12 @@ String InspectorOverlay::EvaluateInOverlayForTest(const String& script) {
return ToCoreStringWithUndefinedOrNullCheck(string);
}
-void InspectorOverlay::OnTimer(TimerBase*) {
+void InspectorOverlayAgent::OnTimer(TimerBase*) {
resize_timer_active_ = false;
ScheduleUpdate();
}
-void InspectorOverlay::ClearInternal() {
+void InspectorOverlayAgent::ClearInternal() {
if (overlay_page_) {
overlay_page_->WillBeDestroyed();
overlay_page_.Clear();
@@ -672,40 +931,22 @@ void InspectorOverlay::ClearInternal() {
}
resize_timer_active_ = false;
paused_in_debugger_message_ = String();
- inspect_mode_ = InspectorDOMAgent::kNotSearching;
+ inspect_mode_ = kNotSearching;
timer_.Stop();
- HideHighlight();
+ InnerHideHighlight();
}
-void InspectorOverlay::Clear() {
- ClearInternal();
- v8_session_ = nullptr;
- dom_agent_.Clear();
- overlay_host_->SetListener(nullptr);
-}
-
-void InspectorOverlay::OverlayResumed() {
+void InspectorOverlayAgent::OverlayResumed() {
if (v8_session_)
v8_session_->resume();
}
-void InspectorOverlay::OverlaySteppedOver() {
+void InspectorOverlayAgent::OverlaySteppedOver() {
if (v8_session_)
v8_session_->stepOver();
}
-void InspectorOverlay::Suspend() {
- if (!suspended_) {
- suspended_ = true;
- ClearInternal();
- }
-}
-
-void InspectorOverlay::Resume() {
- suspended_ = false;
-}
-
-void InspectorOverlay::PageLayoutInvalidated(bool resized) {
+void InspectorOverlayAgent::PageLayoutInvalidated(bool resized) {
if (resized && draw_view_size_) {
resize_timer_active_ = true;
timer_.StartOneShot(1, BLINK_FROM_HERE);
@@ -713,11 +954,7 @@ void InspectorOverlay::PageLayoutInvalidated(bool resized) {
ScheduleUpdate();
}
-void InspectorOverlay::SetShowViewportSizeOnResize(bool show) {
- draw_view_size_ = show;
-}
-
-bool InspectorOverlay::HandleMouseMove(const WebMouseEvent& event) {
+bool InspectorOverlayAgent::HandleMouseMove(const WebMouseEvent& event) {
if (!ShouldSearchForNode())
return false;
@@ -728,7 +965,7 @@ bool InspectorOverlay::HandleMouseMove(const WebMouseEvent& event) {
frame, event, event.GetModifiers() & WebInputEvent::kShiftKey);
// Do not highlight within user agent shadow root unless requested.
- if (inspect_mode_ != InspectorDOMAgent::kSearchingForUAShadow) {
+ if (inspect_mode_ != kSearchingForUAShadow) {
ShadowRoot* shadow_root = InspectorDOMAgent::UserAgentShadowRoot(node);
if (shadow_root)
node = &shadow_root->host();
@@ -746,7 +983,7 @@ bool InspectorOverlay::HandleMouseMove(const WebMouseEvent& event) {
if (frame_owner->ContentFrame() &&
!frame_owner->ContentFrame()->IsLocalFrame()) {
// Do not consume event so that remote frame can handle it.
- HideHighlight();
+ InnerHideHighlight();
hovered_node_for_inspect_mode_.Clear();
return false;
}
@@ -760,16 +997,16 @@ bool InspectorOverlay::HandleMouseMove(const WebMouseEvent& event) {
if (node && inspect_mode_highlight_config_) {
hovered_node_for_inspect_mode_ = node;
- if (dom_agent_)
- dom_agent_->NodeHighlightedInOverlay(node);
- HighlightNode(node, event_target, *inspect_mode_highlight_config_,
- (event.GetModifiers() &
- (WebInputEvent::kControlKey | WebInputEvent::kMetaKey)));
+ NodeHighlightRequested(node);
+ bool omit_tooltip = event.GetModifiers() &
+ (WebInputEvent::kControlKey | WebInputEvent::kMetaKey);
+ InnerHighlightNode(node, event_target, *inspect_mode_highlight_config_,
+ omit_tooltip);
}
return true;
}
-bool InspectorOverlay::HandleMouseDown() {
+bool InspectorOverlayAgent::HandleMouseDown() {
swallow_next_mouse_up_ = false;
if (!ShouldSearchForNode())
return false;
@@ -783,7 +1020,7 @@ bool InspectorOverlay::HandleMouseDown() {
return false;
}
-bool InspectorOverlay::HandleMouseUp() {
+bool InspectorOverlayAgent::HandleMouseUp() {
if (swallow_next_mouse_up_) {
swallow_next_mouse_up_ = false;
return true;
@@ -791,37 +1028,135 @@ bool InspectorOverlay::HandleMouseUp() {
return false;
}
-bool InspectorOverlay::HandleGestureEvent(const WebGestureEvent& event) {
+bool InspectorOverlayAgent::HandleGestureEvent(const WebGestureEvent& event) {
if (!ShouldSearchForNode() || event.GetType() != WebInputEvent::kGestureTap)
return false;
Node* node = HoveredNodeForEvent(frame_impl_->GetFrame(), event, false);
if (node && inspect_mode_highlight_config_) {
- HighlightNode(node, *inspect_mode_highlight_config_, false);
+ InnerHighlightNode(node, nullptr, *inspect_mode_highlight_config_, false);
Inspect(node);
return true;
}
return false;
}
-bool InspectorOverlay::HandleTouchEvent(const WebTouchEvent& event) {
+bool InspectorOverlayAgent::HandleTouchEvent(const WebTouchEvent& event) {
if (!ShouldSearchForNode())
return false;
Node* node = HoveredNodeForEvent(frame_impl_->GetFrame(), event, false);
if (node && inspect_mode_highlight_config_) {
- HighlightNode(node, *inspect_mode_highlight_config_, false);
+ InnerHighlightNode(node, nullptr, *inspect_mode_highlight_config_, false);
Inspect(node);
return true;
}
return false;
}
-bool InspectorOverlay::ShouldSearchForNode() {
- return inspect_mode_ != InspectorDOMAgent::kNotSearching;
+Response InspectorOverlayAgent::CompositingEnabled() {
+ bool main_frame = frame_impl_->ViewImpl() && !frame_impl_->Parent();
+ if (!main_frame || !frame_impl_->ViewImpl()
+ ->GetPage()
+ ->GetSettings()
+ .GetAcceleratedCompositingEnabled())
+ return Response::Error("Compositing mode is not supported");
+ return Response::OK();
}
-void InspectorOverlay::Inspect(Node* node) {
- if (dom_agent_)
- dom_agent_->Inspect(node);
+bool InspectorOverlayAgent::ShouldSearchForNode() {
+ return inspect_mode_ != kNotSearching;
+}
+
+void InspectorOverlayAgent::Inspect(Node* inspected_node) {
+ if (!inspected_node)
+ return;
+
+ Node* node = inspected_node;
+ while (node && !node->IsElementNode() && !node->IsDocumentNode() &&
+ !node->IsDocumentFragment())
+ node = node->ParentOrShadowHostNode();
+ if (!node)
+ return;
+
+ int backend_node_id = DOMNodeIds::IdForNode(node);
+ if (!enabled_) {
+ backend_node_id_to_inspect_ = backend_node_id;
+ return;
+ }
+
+ GetFrontend()->inspectNodeRequested(backend_node_id);
+}
+
+void InspectorOverlayAgent::NodeHighlightRequested(Node* node) {
+ if (!enabled_)
+ return;
+
+ while (node && !node->IsElementNode() && !node->IsDocumentNode() &&
+ !node->IsDocumentFragment())
+ node = node->ParentOrShadowHostNode();
+
+ if (!node)
+ return;
+
+ int node_id = dom_agent_->PushNodePathToFrontend(node);
+ GetFrontend()->nodeHighlightRequested(node_id);
+}
+
+Response InspectorOverlayAgent::SetSearchingForNode(
+ SearchMode search_mode,
+ Maybe<protocol::Overlay::HighlightConfig> highlight_inspector_object) {
+ if (search_mode == kNotSearching) {
+ inspect_mode_ = search_mode;
+ ScheduleUpdate();
+ hovered_node_for_inspect_mode_.Clear();
+ InnerHideHighlight();
+ return Response::OK();
+ }
+
+ std::unique_ptr<InspectorHighlightConfig> config;
+ Response response = HighlightConfigFromInspectorObject(
+ std::move(highlight_inspector_object), &config);
+ if (!response.isSuccess())
+ return response;
+ inspect_mode_ = search_mode;
+ inspect_mode_highlight_config_ = std::move(config);
+ ScheduleUpdate();
+ return Response::OK();
+}
+
+Response InspectorOverlayAgent::HighlightConfigFromInspectorObject(
+ Maybe<protocol::Overlay::HighlightConfig> highlight_inspector_object,
+ std::unique_ptr<InspectorHighlightConfig>* out_config) {
+ if (!highlight_inspector_object.isJust()) {
+ return Response::Error(
+ "Internal error: highlight configuration parameter is missing");
+ }
+
+ protocol::Overlay::HighlightConfig* config =
+ highlight_inspector_object.fromJust();
+ std::unique_ptr<InspectorHighlightConfig> highlight_config =
+ WTF::MakeUnique<InspectorHighlightConfig>();
+ highlight_config->show_info = config->getShowInfo(false);
+ highlight_config->show_rulers = config->getShowRulers(false);
+ highlight_config->show_extension_lines = config->getShowExtensionLines(false);
+ highlight_config->display_as_material = config->getDisplayAsMaterial(false);
+ highlight_config->content =
+ InspectorDOMAgent::ParseColor(config->getContentColor(nullptr));
+ highlight_config->padding =
+ InspectorDOMAgent::ParseColor(config->getPaddingColor(nullptr));
+ highlight_config->border =
+ InspectorDOMAgent::ParseColor(config->getBorderColor(nullptr));
+ highlight_config->margin =
+ InspectorDOMAgent::ParseColor(config->getMarginColor(nullptr));
+ highlight_config->event_target =
+ InspectorDOMAgent::ParseColor(config->getEventTargetColor(nullptr));
+ highlight_config->shape =
+ InspectorDOMAgent::ParseColor(config->getShapeColor(nullptr));
+ highlight_config->shape_margin =
+ InspectorDOMAgent::ParseColor(config->getShapeMarginColor(nullptr));
+ highlight_config->selector_list = config->getSelectorList("");
+
+ *out_config = std::move(highlight_config);
+ return Response::OK();
}
} // namespace blink
« no previous file with comments | « third_party/WebKit/Source/web/InspectorOverlayAgent.h ('k') | third_party/WebKit/Source/web/InspectorRenderingAgent.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698