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 |