Revert of [DevTools] Consolidate overlay-related functionality in Overlay domain

third_party/WebKit/Source/core/inspector/InspectorDOMAgent.h

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 16 matching lines @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef InspectorDOMAgent_h
 #define InspectorDOMAgent_h
 
 #include <memory>
 #include "core/CoreExport.h"
 #include "core/events/EventListenerMap.h"
 #include "core/inspector/InspectorBaseAgent.h"
+#include "core/inspector/InspectorHighlight.h"
 #include "core/inspector/protocol/DOM.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/wtf/HashMap.h"
 #include "platform/wtf/HashSet.h"
 #include "platform/wtf/RefPtr.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/text/AtomicString.h"
 #include "v8/include/v8-inspector.h"
 
 namespace blink {
 
 class CharacterData;
-class Color;
 class DOMEditor;
 class Document;
 class DocumentLoader;
 class Element;
 class ExceptionState;
 class FloatQuad;
 class HTMLSlotElement;
 class InsertionPoint;
 class InspectedFrames;
 class InspectorHistory;
 class Node;
 class QualifiedName;
 class PseudoElement;
 class InspectorRevalidateDOMTask;
 class ShadowRoot;
 
 class CORE_EXPORT InspectorDOMAgent final
     : public InspectorBaseAgent<protocol::DOM::Metainfo> {
   WTF_MAKE_NONCOPYABLE(InspectorDOMAgent);
 
  public:
   struct CORE_EXPORT DOMListener : public GarbageCollectedMixin {
     virtual ~DOMListener() {}
     virtual void DidAddDocument(Document*) = 0;
     virtual void DidRemoveDocument(Document*) = 0;
     virtual void DidRemoveDOMNode(Node*) = 0;
     virtual void DidModifyDOMAttr(Element*) = 0;
   };
 
+  enum SearchMode {
+    kNotSearching,
+    kSearchingForNormal,
+    kSearchingForUAShadow,
+  };
+
+  class Client {
+   public:
+    virtual ~Client() {}
+    virtual void HideHighlight() {}
+    virtual void HighlightNode(Node*,
+                               const InspectorHighlightConfig&,
+                               bool omit_tooltip) {}
+    virtual void HighlightQuad(std::unique_ptr<FloatQuad>,
+                               const InspectorHighlightConfig&) {}
+    virtual void SetInspectMode(SearchMode search_mode,
+                                std::unique_ptr<InspectorHighlightConfig>) {}
+  };
+
   static protocol::Response ToResponse(ExceptionState&);
   static bool GetPseudoElementType(PseudoId, String*);
   static ShadowRoot* UserAgentShadowRoot(Node*);
-  static Color ParseColor(protocol::DOM::RGBA*);
 
   InspectorDOMAgent(v8::Isolate*,
                     InspectedFrames*,
-                    v8_inspector::V8InspectorSession*);
+                    v8_inspector::V8InspectorSession*,
+                    Client*);
   ~InspectorDOMAgent() override;
   DECLARE_VIRTUAL_TRACE();
 
   void Restore() override;
 
   HeapVector<Member<Document>> Documents();
   void Reset();
 
   // Methods called from the frontend for DOM nodes inspection.
   protocol::Response enable() override;
@@ skipping 41 matching lines @@
       String* search_id,
       int* result_count) override;
   protocol::Response getSearchResults(
       const String& search_id,
       int from_index,
       int to_index,
       std::unique_ptr<protocol::Array<int>>* node_ids) override;
   protocol::Response discardSearchResults(const String& search_id) override;
   protocol::Response requestNode(const String& object_id,
                                  int* out_node_id) override;
+  protocol::Response setInspectMode(
+      const String& mode,
+      protocol::Maybe<protocol::DOM::HighlightConfig>) override;
+  protocol::Response highlightRect(
+      int x,
+      int y,
+      int width,
+      int height,
+      protocol::Maybe<protocol::DOM::RGBA> color,
+      protocol::Maybe<protocol::DOM::RGBA> outline_color) override;
+  protocol::Response highlightQuad(
+      std::unique_ptr<protocol::Array<double>> quad,
+      protocol::Maybe<protocol::DOM::RGBA> color,
+      protocol::Maybe<protocol::DOM::RGBA> outline_color) override;
+  protocol::Response highlightNode(
+      std::unique_ptr<protocol::DOM::HighlightConfig>,
+      protocol::Maybe<int> node_id,
+      protocol::Maybe<int> backend_node_id,
+      protocol::Maybe<String> object_id) override;
+  protocol::Response hideHighlight() override;
+  protocol::Response highlightFrame(
+      const String& frame_id,
+      protocol::Maybe<protocol::DOM::RGBA> content_color,
+      protocol::Maybe<protocol::DOM::RGBA> content_outline_color) override;
   protocol::Response pushNodeByPathToFrontend(const String& path,
                                               int* out_node_id) override;
   protocol::Response pushNodesByBackendIdsToFrontend(
       std::unique_ptr<protocol::Array<int>> backend_node_ids,
       std::unique_ptr<protocol::Array<int>>* node_ids) override;
   protocol::Response setInspectedNode(int node_id) override;
   protocol::Response resolveNode(
       int node_id,
       protocol::Maybe<String> object_group,
       std::unique_ptr<v8_inspector::protocol::Runtime::API::RemoteObject>*)
@@ skipping 19 matching lines @@
   protocol::Response getBoxModel(
       int node_id,
       std::unique_ptr<protocol::DOM::BoxModel>*) override;
   protocol::Response getNodeForLocation(
       int x,
       int y,
       protocol::Maybe<bool> include_user_agent_shadow_dom,
       int* out_node_id) override;
   protocol::Response getRelayoutBoundary(int node_id,
                                          int* out_node_id) override;
+  protocol::Response getHighlightObjectForTest(
+      int node_id,
+      std::unique_ptr<protocol::DictionaryValue>* highlight) override;
 
   bool Enabled() const;
   void ReleaseDanglingNodes();
 
   // Methods called from the InspectorInstrumentation.
   void DomContentLoadedEventFired(LocalFrame*);
   void DidCommitLoad(LocalFrame*, DocumentLoader*);
   void DidInsertDOMNode(Node*);
   void WillRemoveDOMNode(Node*);
   void WillModifyDOMAttr(Element*,
@@ skipping 10 matching lines @@
   void WillPopShadowRoot(Element* host, ShadowRoot*);
   void DidPerformElementShadowDistribution(Element*);
   void DidPerformSlotDistribution(HTMLSlotElement*);
   void FrameDocumentUpdated(LocalFrame*);
   void PseudoElementCreated(PseudoElement*);
   void PseudoElementDestroyed(PseudoElement*);
 
   Node* NodeForId(int node_id);
   int BoundNodeId(Node*);
   void SetDOMListener(DOMListener*);
+  void Inspect(Node*);
+  void NodeHighlightedInOverlay(Node*);
   int PushNodePathToFrontend(Node*);
-  protocol::Response PushDocumentUponHandlelessOperation();
-  protocol::Response NodeForRemoteObjectId(const String& remote_object_id,
-                                           Node*&);
 
   static String DocumentURLString(Document*);
 
   std::unique_ptr<v8_inspector::protocol::Runtime::API::RemoteObject>
   ResolveNode(Node*, const String& object_group);
 
   InspectorHistory* History() { return history_.Get(); }
 
   // We represent embedded doms as a part of the same hierarchy. Hence we treat
   // children of frame owners differently.  We also skip whitespace text nodes
@@ skipping 12 matching lines @@
                            HeapVector<Member<Node>>* result);
 
   protocol::Response AssertNode(int node_id, Node*&);
   protocol::Response AssertElement(int node_id, Element*&);
   Document* GetDocument() const { return document_.Get(); }
 
  private:
   void SetDocument(Document*);
   void InnerEnable();
 
+  protocol::Response SetSearchingForNode(
+      SearchMode,
+      protocol::Maybe<protocol::DOM::HighlightConfig>);
+  protocol::Response HighlightConfigFromInspectorObject(
+      protocol::Maybe<protocol::DOM::HighlightConfig>
+          highlight_inspector_object,
+      std::unique_ptr<InspectorHighlightConfig>*);
+
   // Node-related methods.
   typedef HeapHashMap<Member<Node>, int> NodeToIdMap;
   int Bind(Node*, NodeToIdMap*);
   void Unbind(Node*, NodeToIdMap*);
 
   protocol::Response AssertEditableNode(int node_id, Node*&);
   protocol::Response AssertEditableChildNode(Element* parent_element,
                                              int node_id,
                                              Node*&);
   protocol::Response AssertEditableElement(int node_id, Element*&);
@@ skipping 21 matching lines @@
       NodeToIdMap* nodes_map,
       protocol::Array<protocol::DOM::Node>* flatten_result);
   std::unique_ptr<protocol::Array<protocol::DOM::Node>>
   BuildArrayForPseudoElements(Element*, NodeToIdMap* nodes_map);
   std::unique_ptr<protocol::Array<protocol::DOM::BackendNode>>
   BuildArrayForDistributedNodes(InsertionPoint*);
   std::unique_ptr<protocol::Array<protocol::DOM::BackendNode>>
   BuildDistributedNodesForSlot(HTMLSlotElement*);
 
   Node* NodeForPath(const String& path);
+  protocol::Response NodeForRemoteId(const String& id, Node*&);
 
   void DiscardFrontendBindings();
 
+  void InnerHighlightQuad(std::unique_ptr<FloatQuad>,
+                          protocol::Maybe<protocol::DOM::RGBA> color,
+                          protocol::Maybe<protocol::DOM::RGBA> outline_color);
+
+  protocol::Response PushDocumentUponHandlelessOperation();
+
   InspectorRevalidateDOMTask* RevalidateTask();
 
   v8::Isolate* isolate_;
   Member<InspectedFrames> inspected_frames_;
   v8_inspector::V8InspectorSession* v8_session_;
+  Client* client_;
   Member<DOMListener> dom_listener_;
   Member<NodeToIdMap> document_node_to_id_map_;
   // Owns node mappings for dangling nodes.
   HeapVector<Member<NodeToIdMap>> dangling_node_to_id_maps_;
   HeapHashMap<int, Member<Node>> id_to_node_;
   HeapHashMap<int, Member<NodeToIdMap>> id_to_nodes_map_;
   HashSet<int> children_requested_;
   HashSet<int> distributed_nodes_requested_;
   HashMap<int, int> cached_child_count_;
   int last_node_id_;
   Member<Document> document_;
   typedef HeapHashMap<String, HeapVector<Member<Node>>> SearchResults;
   SearchResults search_results_;
   Member<InspectorRevalidateDOMTask> revalidate_task_;
   Member<InspectorHistory> history_;
   Member<DOMEditor> dom_editor_;
   bool suppress_attribute_modified_event_;
+  int backend_node_id_to_inspect_;
 };
 
 }  // namespace blink
 
 #endif  // !defined(InspectorDOMAgent_h)