Inspector: wrapped inspector agent instances into factory-like wrappers

Source/core/inspector/InspectorTimelineAgent.h

 /*
 * Copyright (C) 2012 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:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
@@ skipping 37 matching lines @@
 struct CachedResourceInitiatorInfo;
 class DOMWindow;
 class Document;
 class DocumentLoader;
 class Event;
 class FloatQuad;
 class Frame;
 class GraphicsContext;
 class InspectorClient;
 class InspectorDOMAgent;
+class InspectorDOMController;
 class InspectorFrontend;
 class InspectorMemoryAgent;
+class InspectorMemoryController;
 class InspectorPageAgent;
+class InspectorPageController;
 class InspectorState;
 class InstrumentingAgents;
 class IntRect;
 class KURL;
 class Node;
 class Page;
 class RenderObject;
 class ResourceError;
 class ResourceLoader;
 class ResourceRequest;
@@ skipping 21 matching lines @@
     {
     }
     double fromMonotonicallyIncreasingTime(double time) const  { return (time - m_startOffset) * 1000.0; }
     void reset();
 
 private:
     double m_startOffset;
 };
 
 class InspectorTimelineAgent
-    : public InspectorBaseAgent<InspectorTimelineAgent>,
+    : public InspectorBaseAgent,
       public ScriptGCEventListener,
       public InspectorBackendDispatcher::TimelineCommandHandler,
       public PlatformInstrumentationClient {
     WTF_MAKE_NONCOPYABLE(InspectorTimelineAgent);
 public:
     enum InspectorType { PageInspector, WorkerInspector };
 
-    static PassOwnPtr<InspectorTimelineAgent> create(InstrumentingAgents* instrumentingAgents, InspectorPageAgent* pageAgent, InspectorMemoryAgent* memoryAgent, InspectorDOMAgent* domAgent, InspectorCompositeState* state, InspectorType type, InspectorClient* client)
-    {
-        return adoptPtr(new InspectorTimelineAgent(instrumentingAgents, pageAgent, memoryAgent, domAgent, state, type, client));
-    }
+    static PassRefPtr<InspectorTimelineAgent> create(InstrumentingAgents*, InspectorState*, PassRefPtr<InspectorPageAgent>, PassRefPtr<InspectorMemoryAgent>, PassRefPtr<InspectorDOMAgent>, InspectorType, InspectorClient*);
 
     ~InspectorTimelineAgent();
 
     virtual void setFrontend(InspectorFrontend*);
     virtual void clearFrontend();
     virtual void restore();
 
     virtual void start(ErrorString*, const int* maxCallStackDepth, const bool* includeDomCounters, const bool* includeNativeMemoryStatistics);
     virtual void stop(ErrorString*);
 
@@ skipping 94 matching lines @@
             : record(record), data(data), children(children), type(type), usedHeapSizeAtStart(usedHeapSizeAtStart)
         {
         }
         RefPtr<InspectorObject> record;
         RefPtr<InspectorObject> data;
         RefPtr<InspectorArray> children;
         String type;
         size_t usedHeapSizeAtStart;
     };
         
-    InspectorTimelineAgent(InstrumentingAgents*, InspectorPageAgent*, InspectorMemoryAgent*, InspectorDOMAgent*, InspectorCompositeState*, InspectorType, InspectorClient*);
+    InspectorTimelineAgent(InstrumentingAgents*, InspectorState*, PassRefPtr<InspectorPageAgent>, PassRefPtr<InspectorMemoryAgent>, PassRefPtr<InspectorDOMAgent>, InspectorType, InspectorClient*);
 
     void didFinishLoadingResource(unsigned long, bool didFail, double finishTime, Frame*);
 
     void sendEvent(PassRefPtr<InspectorObject>);
     void appendRecord(PassRefPtr<InspectorObject> data, const String& type, bool captureCallStack, Frame*);
     void pushCurrentRecord(PassRefPtr<InspectorObject>, const String& type, bool captureCallStack, Frame*, bool hasLowLevelDetails = false);
 
     void setDOMCounters(TypeBuilder::Timeline::TimelineEvent* record);
     void setNativeHeapStatistics(TypeBuilder::Timeline::TimelineEvent* record);
     void setFrameIdentifier(InspectorObject* record, Frame*);
     void pushGCEventRecords();
 
     void didCompleteCurrentRecord(const String& type);
 
     void setHeapSizeStatistics(InspectorObject* record);
     void commitFrameRecord();
 
     void addRecordToTimeline(PassRefPtr<InspectorObject>);
     void innerAddRecordToTimeline(PassRefPtr<InspectorObject>);
     void clearRecordStack();
 
     void localToPageQuad(const RenderObject& renderer, const LayoutRect&, FloatQuad*);
     const TimelineTimeConverter& timeConverter() const { return m_timeConverter; }
     long long idForNode(Node*);
     void releaseNodeIds();
 
     double timestamp();
     Page* page();
 
-    InspectorPageAgent* m_pageAgent;
-    InspectorMemoryAgent* m_memoryAgent;
-    InspectorDOMAgent* m_domAgent;
+    RefPtr<InspectorPageAgent> m_pageAgent;
+    RefPtr<InspectorMemoryAgent> m_memoryAgent;
+    RefPtr<InspectorDOMAgent> m_domAgent;
     TimelineTimeConverter m_timeConverter;
 
     InspectorFrontend::Timeline* m_frontend;
     double m_timestampOffset;
 
     Vector<TimelineRecordEntry> m_recordStack;
 
     int m_id;
     struct GCEvent {
         GCEvent(double startTime, double endTime, size_t collectedBytes)
             : startTime(startTime), endTime(endTime), collectedBytes(collectedBytes)
         {
         }
         double startTime;
         double endTime;
         size_t collectedBytes;
     };
     typedef Vector<GCEvent> GCEvents;
     GCEvents m_gcEvents;
     int m_maxCallStackDepth;
     unsigned m_platformInstrumentationClientInstalledAtStackDepth;
     RefPtr<InspectorObject> m_pendingFrameRecord;
     InspectorType m_inspectorType;
     InspectorClient* m_client;
     WeakPtrFactory<InspectorTimelineAgent> m_weakFactory;
     RefPtr<TimelineTraceEventProcessor> m_traceEventProcessor;
     unsigned m_styleRecalcElementCounter;
 };
 
+class InspectorTimelineController: public InspectorBaseController<InspectorTimelineController, InspectorTimelineAgent> {
+public:
+
+    static PassOwnPtr<InspectorTimelineController> create(InstrumentingAgents* instrumentingAgents, InspectorCompositeState* compositeState, InspectorPageController* pageController, InspectorMemoryController* memoryController, InspectorDOMController* domController, InspectorTimelineAgent::InspectorType type, InspectorClient* client)
+    {
+        return adoptPtr(new InspectorTimelineController(instrumentingAgents, compositeState, pageController, memoryController, domController, type, client));
+    }
+
+protected:
+    InspectorTimelineController(InstrumentingAgents*, InspectorCompositeState*, InspectorPageController*, InspectorMemoryController*, InspectorDOMController*, InspectorTimelineAgent::InspectorType, InspectorClient*);
+};
+
 } // namespace WebCore
 
 #endif // !defined(InspectorTimelineAgent_h)