Inspector: wrapped inspector agent instances into factory-like wrappers

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 44 matching lines @@
 class CharacterData;
 class DOMEditor;
 class Document;
 class Element;
 class Event;
 class InspectorClient;
 class InspectorFrontend;
 class InspectorHistory;
 class InspectorOverlay;
 class InspectorPageAgent;
+class InspectorPageFactory;
 class HTMLElement;
 class InspectorState;
 class InstrumentingAgents;
 class NameNodeMap;
 class Node;
 class PlatformTouchEvent;
 class RevalidateStyleAttributeTask;
 class ScriptValue;
 class ShadowRoot;
 
 struct HighlightConfig;
 
 typedef String ErrorString;
 typedef int BackendNodeId;
 
 
 struct EventListenerInfo {
     EventListenerInfo(Node* node, const AtomicString& eventType, const EventListenerVector& eventListenerVector)
         : node(node)
         , eventType(eventType)
         , eventListenerVector(eventListenerVector)
     {
     }
 
     Node* node;
     const AtomicString eventType;
     const EventListenerVector eventListenerVector;
 };
 
-class InspectorDOMAgent : public InspectorBaseAgent<InspectorDOMAgent>, public InspectorBackendDispatcher::DOMCommandHandler {
+class InspectorDOMAgent : public InspectorBaseAgent, public InspectorBackendDispatcher::DOMCommandHandler {
     WTF_MAKE_NONCOPYABLE(InspectorDOMAgent);
 public:
     struct DOMListener {
         virtual ~DOMListener()
         {
         }
         virtual void didRemoveDocument(Document*) = 0;
         virtual void didRemoveDOMNode(Node*) = 0;
         virtual void didModifyDOMAttr(Element*) = 0;
     };
 
-    static PassOwnPtr<InspectorDOMAgent> create(InstrumentingAgents* instrumentingAgents, InspectorPageAgent* pageAgent, InspectorCompositeState* inspectorState, InjectedScriptManager* injectedScriptManager, InspectorOverlay* overlay, InspectorClient* client)
-    {
-        return adoptPtr(new InspectorDOMAgent(instrumentingAgents, pageAgent, inspectorState, injectedScriptManager, overlay, client));
-    }
+    static PassRefPtr<InspectorDOMAgent> create(InstrumentingAgents*, InspectorState*, PassRefPtr<InspectorPageAgent>, InjectedScriptManager*, InspectorOverlay*, InspectorClient*);
 
     static String toErrorString(const ExceptionCode&);
 
-    ~InspectorDOMAgent();
+    virtual ~InspectorDOMAgent();
 
     virtual void setFrontend(InspectorFrontend*);
     virtual void clearFrontend();
     virtual void restore();
 
     Vector<Document*> documents();
     void reset();
 
     // Methods called from the frontend for DOM nodes inspection.
     virtual void querySelector(ErrorString*, int nodeId, const String& selectors, int* elementId);
@@ skipping 75 matching lines @@
     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);
 
-    // Methods called from other agents.
-    InspectorPageAgent* pageAgent() { return m_pageAgent; }
-
 private:
-    InspectorDOMAgent(InstrumentingAgents*, InspectorPageAgent*, InspectorCompositeState*, InjectedScriptManager*, InspectorOverlay*, InspectorClient*);
+    InspectorDOMAgent(InstrumentingAgents*, InspectorState*, PassRefPtr<InspectorPageAgent>, InjectedScriptManager*, InspectorOverlay*, InspectorClient*);
 
     void setSearchingForNode(ErrorString*, bool enabled, InspectorObject* highlightConfig);
     PassOwnPtr<HighlightConfig> highlightConfigFromInspectorObject(ErrorString*, InspectorObject* highlightInspectorObject);
 
     // Node-related methods.
     typedef HashMap<RefPtr<Node>, int> NodeToIdMap;
     int bind(Node*, NodeToIdMap*);
     void unbind(Node*, NodeToIdMap*);
 
     Node* assertEditableNode(ErrorString*, int nodeId);
@@ skipping 13 matching lines @@
     PassRefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > buildArrayForContainerChildren(Node* container, int depth, NodeToIdMap* nodesMap);
     PassRefPtr<TypeBuilder::DOM::EventListener> buildObjectForEventListener(const RegisteredEventListener&, const AtomicString& eventType, Node*, const String* objectGroupId);
 
     Node* nodeForPath(const String& path);
 
     void discardBackendBindings();
     void discardFrontendBindings();
 
     void innerHighlightQuad(PassOwnPtr<FloatQuad>, const RefPtr<InspectorObject>* color, const RefPtr<InspectorObject>* outlineColor);
 
-    InspectorPageAgent* m_pageAgent;
+    RefPtr<InspectorPageAgent> m_pageAgent;
     InjectedScriptManager* m_injectedScriptManager;
     InspectorOverlay* m_overlay;
     InspectorClient* m_client;
     InspectorFrontend::DOM* m_frontend;
     DOMListener* m_domListener;
     NodeToIdMap m_documentNodeToIdMap;
     typedef HashMap<RefPtr<Node>, BackendNodeId> NodeToBackendIdMap;
     HashMap<String, NodeToBackendIdMap> m_nodeGroupToBackendIdMap;
     // Owns node mappings for dangling nodes.
     Vector<OwnPtr<NodeToIdMap> > m_danglingNodeToIdMaps;
     HashMap<int, Node*> m_idToNode;
     HashMap<int, NodeToIdMap*> m_idToNodesMap;
     HashSet<int> m_childrenRequested;
     HashMap<BackendNodeId, std::pair<Node*, String> > m_backendIdToNode;
     int m_lastNodeId;
     BackendNodeId m_lastBackendNodeId;
     RefPtr<Document> m_document;
     typedef HashMap<String, Vector<RefPtr<Node> > > SearchResults;
     SearchResults m_searchResults;
     OwnPtr<RevalidateStyleAttributeTask> m_revalidateStyleAttrTask;
     bool m_searchingForNode;
     OwnPtr<HighlightConfig> m_inspectModeHighlightConfig;
     OwnPtr<InspectorHistory> m_history;
     OwnPtr<DOMEditor> m_domEditor;
     bool m_suppressAttributeModifiedEvent;
 };
 
 
+class InspectorDOMFactory : public InspectorBaseFactory<InspectorDOMFactory, InspectorDOMAgent> {
+public:
+
+    static PassOwnPtr<InspectorDOMFactory> create(InstrumentingAgents* instrumentingAgents, InspectorCompositeState* compositeState, InspectorPageFactory* pageFactory, InjectedScriptManager* injectedScriptManager, InspectorOverlay* overlay, InspectorClient* client)
+    {
+        return adoptPtr(new InspectorDOMFactory(instrumentingAgents, compositeState, pageFactory, injectedScriptManager, overlay, client));
+    }
+
+protected:
+    InspectorDOMFactory(InstrumentingAgents*, InspectorCompositeState*, InspectorPageFactory*, InjectedScriptManager*, InspectorOverlay*, InspectorClient*);
+};
+
 } // namespace WebCore
 
 #endif // !defined(InspectorDOMAgent_h)