[instrumentation] Generalize instrumentation to be used beyond the core layer

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

 /*
 * Copyright (C) 2010 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 21 matching lines @@
 #define InspectorInstrumentation_h
 
 #include "core/CoreExport.h"
 #include "core/dom/Document.h"
 #include "core/dom/Node.h"
 #include "core/frame/LocalFrame.h"
 #include "core/page/ChromeClient.h"
 
 namespace blink {
 
-class InstrumentingAgents;
+class InspectorInstrumentationAgents;
 class Resource;
 class ThreadDebugger;
 class WorkerGlobalScope;
 
 namespace probe {
 
 class CORE_EXPORT ProbeBase {
   STACK_ALLOCATED()
 
  public:
@@ skipping 16 matching lines @@
             bool enabled = true);
   ~AsyncTask();
 
  private:
   ThreadDebugger* m_debugger;
   void* m_task;
   bool m_recurring;
 };
 
 // Called from generated instrumentation code.
-CORE_EXPORT InstrumentingAgents* instrumentingAgentsFor(WorkerGlobalScope*);
-CORE_EXPORT InstrumentingAgents* instrumentingAgentsForNonDocumentContext(
-    ExecutionContext*);
+CORE_EXPORT InspectorInstrumentationAgents* instrumentingAgentsFor(
+    WorkerGlobalScope*);
+CORE_EXPORT InspectorInstrumentationAgents*
+instrumentingAgentsForNonDocumentContext(ExecutionContext*);
 
-inline InstrumentingAgents* instrumentingAgentsFor(LocalFrame* frame) {
+inline InspectorInstrumentationAgents* instrumentingAgentsFor(
+    LocalFrame* frame) {
   return frame ? frame->instrumentingAgents() : nullptr;
 }
 
-inline InstrumentingAgents* instrumentingAgentsFor(Document& document) {
+inline InspectorInstrumentationAgents* instrumentingAgentsFor(
+    Document& document) {
   LocalFrame* frame = document.frame();
   if (!frame && document.templateDocumentHost())
     frame = document.templateDocumentHost()->frame();
   return instrumentingAgentsFor(frame);
 }
 
-inline InstrumentingAgents* instrumentingAgentsFor(Document* document) {
+inline InspectorInstrumentationAgents* instrumentingAgentsFor(
+    Document* document) {
   return document ? instrumentingAgentsFor(*document) : nullptr;
 }
 
-inline InstrumentingAgents* instrumentingAgentsFor(ExecutionContext* context) {
+inline InspectorInstrumentationAgents* instrumentingAgentsFor(
+    ExecutionContext* context) {
   if (!context)
     return nullptr;
   return context->isDocument()
              ? instrumentingAgentsFor(*toDocument(context))
              : instrumentingAgentsForNonDocumentContext(context);
 }
 
-inline InstrumentingAgents* instrumentingAgentsFor(Node* node) {
+inline InspectorInstrumentationAgents* instrumentingAgentsFor(Node* node) {
   return node ? instrumentingAgentsFor(node->document()) : nullptr;
 }
 
-inline InstrumentingAgents* instrumentingAgentsFor(EventTarget* eventTarget) {
+inline InspectorInstrumentationAgents* instrumentingAgentsFor(
+    EventTarget* eventTarget) {
   return eventTarget
              ? instrumentingAgentsFor(eventTarget->getExecutionContext())
              : nullptr;
 }
 
 CORE_EXPORT void asyncTaskScheduled(ExecutionContext*,
                                     const String& name,
                                     void*);
 CORE_EXPORT void asyncTaskScheduledBreakable(ExecutionContext*,
                                              const char* name,
                                              void*);
 CORE_EXPORT void asyncTaskCanceled(ExecutionContext*, void*);
 CORE_EXPORT void asyncTaskCanceledBreakable(ExecutionContext*,
                                             const char* name,
                                             void*);
 
 CORE_EXPORT void allAsyncTasksCanceled(ExecutionContext*);
 CORE_EXPORT void canceledAfterReceivedResourceResponse(LocalFrame*,
                                                        DocumentLoader*,
                                                        unsigned long identifier,
                                                        const ResourceResponse&,
                                                        Resource*);
 CORE_EXPORT void continueWithPolicyIgnore(LocalFrame*,
                                           DocumentLoader*,
                                           unsigned long identifier,
                                           const ResourceResponse&,
                                           Resource*);
 
-}  // namespace InspectorInstrumentation
+}  // namespace probe
 }  // namespace blink
 
 #include "core/InspectorInstrumentationInl.h"
-
 #include "core/InspectorOverridesInl.h"
 
 #endif  // !defined(InspectorInstrumentation_h)