Devtools: Move inspectMode logic from InspectorDomAgent to InspectorOverlayImpl

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 18 matching lines @@
 
 #ifndef InspectorDOMAgent_h
 #define InspectorDOMAgent_h
 
 #include "core/CoreExport.h"
 #include "core/InspectorFrontend.h"
 #include "core/events/EventListenerMap.h"
 #include "core/inspector/InjectedScript.h"
 #include "core/inspector/InjectedScriptManager.h"
 #include "core/inspector/InspectorBaseAgent.h"
+#include "core/inspector/InspectorHighlight.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "platform/JSONValues.h"
 #include "platform/geometry/FloatQuad.h"
 
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
@@ skipping 15 matching lines @@
 class InspectorPageAgent;
 class Node;
 class QualifiedName;
 class PseudoElement;
 class PlatformGestureEvent;
 class PlatformMouseEvent;
 class PlatformTouchEvent;
 class InspectorRevalidateDOMTask;
 class ShadowRoot;
 
-struct InspectorHighlightConfig;
-
 typedef String ErrorString;
 
 class CORE_EXPORT InspectorDOMAgent final : public InspectorBaseAgent<InspectorDOMAgent, InspectorFrontend::DOM>, public InspectorBackendDispatcher::DOMCommandHandler {
     WTF_MAKE_NONCOPYABLE(InspectorDOMAgent);
 public:
     struct CORE_EXPORT DOMListener : public WillBeGarbageCollectedMixin {
         virtual ~DOMListener()
         {
         }
         virtual void didRemoveDocument(Document*) = 0;
         virtual void didRemoveDOMNode(Node*) = 0;
         virtual void didModifyDOMAttr(Element*) = 0;
     };
 
+    enum SearchMode { NotSearching, SearchingForNormal, SearchingForUAShadow };
+
     class Client {
     public:
         virtual ~Client() { }
-        virtual void setInspectModeEnabled(bool) { }
         virtual void hideHighlight() { }
-        virtual void highlightNode(Node*, Node* eventTarget, const InspectorHighlightConfig&, bool omitTooltip) { }
+        virtual void highlightNode(Node*, const InspectorHighlightConfig&, bool omitTooltip) { }
         virtual void highlightQuad(PassOwnPtr<FloatQuad>, const InspectorHighlightConfig&) { }
+        virtual void setInspectMode(SearchMode searchMode, PassOwnPtr<InspectorHighlightConfig>) { }
     };
 
     static PassOwnPtrWillBeRawPtr<InspectorDOMAgent> create(InspectorPageAgent* pageAgent, InjectedScriptManager* injectedScriptManager, Client* client)
     {
         return adoptPtrWillBeNoop(new InspectorDOMAgent(pageAgent, injectedScriptManager, client));
     }
 
     static String toErrorString(ExceptionState&);
     static bool getPseudoElementType(PseudoId, TypeBuilder::DOM::PseudoType::Enum*);
+    static ShadowRoot* userAgentShadowRoot(Node*);
 
     ~InspectorDOMAgent() override;
     DECLARE_VIRTUAL_TRACE();
 
     void disable(ErrorString*) override;
     void restore() override;
 
     WillBeHeapVector<RawPtrWillBeMember<Document> > documents();
     void reset();
 
@@ skipping 61 matching lines @@
     void pseudoElementDestroyed(PseudoElement*);
 
     Node* nodeForId(int nodeId);
     int boundNodeId(Node*);
     void setDOMListener(DOMListener*);
     void inspect(Node*);
 
     static String documentURLString(Document*);
 
     PassRefPtr<TypeBuilder::Runtime::RemoteObject> resolveNode(Node*, const String& objectGroup);
-    bool handleMousePress();
-    bool handleGestureEvent(LocalFrame*, const PlatformGestureEvent&);
-    bool handleTouchEvent(LocalFrame*, const PlatformTouchEvent&);
-    bool handleMouseMove(LocalFrame*, const PlatformMouseEvent&);
 
     InspectorHistory* history() { return m_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 conditionally. Following methods encapsulate these specifics.
     static Node* innerFirstChild(Node*);
     static Node* innerNextSibling(Node*);
     static Node* innerPreviousSibling(Node*);
     static unsigned innerChildNodeCount(Node*);
     static Node* innerParentNode(Node*);
     static bool isWhitespace(Node*);
 
     Node* assertNode(ErrorString*, int nodeId);
     Element* assertElement(ErrorString*, int nodeId);
     Document* assertDocument(ErrorString*, int nodeId);
 
 private:
-    enum SearchMode { NotSearching, SearchingForNormal, SearchingForUAShadow };
-
     InspectorDOMAgent(InspectorPageAgent*, InjectedScriptManager*, Client*);
 
     void setDocument(Document*);
     void innerEnable();
 
     void setSearchingForNode(ErrorString*, SearchMode, JSONObject* highlightConfig);
     PassOwnPtr<InspectorHighlightConfig> highlightConfigFromInspectorObject(ErrorString*, JSONObject* highlightInspectorObject);
 
     // Node-related methods.
     typedef WillBeHeapHashMap<RefPtrWillBeMember<Node>, int> NodeToIdMap;
@@ skipping 37 matching lines @@
     WillBeHeapHashMap<int, RawPtrWillBeMember<Node> > m_idToNode;
     WillBeHeapHashMap<int, RawPtrWillBeMember<NodeToIdMap> > m_idToNodesMap;
     HashSet<int> m_childrenRequested;
     HashSet<int> m_distributedNodesRequested;
     HashMap<int, int> m_cachedChildCount;
     int m_lastNodeId;
     RefPtrWillBeMember<Document> m_document;
     typedef WillBeHeapHashMap<String, WillBeHeapVector<RefPtrWillBeMember<Node> > > SearchResults;
     SearchResults m_searchResults;
     OwnPtrWillBeMember<InspectorRevalidateDOMTask> m_revalidateTask;
-    SearchMode m_searchingForNode;
-    OwnPtr<InspectorHighlightConfig> m_inspectModeHighlightConfig;
-    RefPtrWillBeMember<Node> m_hoveredNodeForInspectMode;
     OwnPtrWillBeMember<InspectorHistory> m_history;
     OwnPtrWillBeMember<DOMEditor> m_domEditor;
     bool m_suppressAttributeModifiedEvent;
     int m_backendNodeIdToInspect;
 };
 
 
 } // namespace blink
 
 #endif // !defined(InspectorDOMAgent_h)