Rename WebCore namespace to blink in Platform

Source/platform/TraceEvent.h

 /*
  * 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.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 154 matching lines @@
 
 #include "platform/EventTracer.h"
 
 #include "wtf/DynamicAnnotations.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/text/CString.h"
 
 // By default, const char* argument values are assumed to have long-lived scope
 // and will not be copied. Use this macro to force a const char* to be copied.
 #define TRACE_STR_COPY(str) \
-    WebCore::TraceEvent::TraceStringWithCopy(str)
+    blink::TraceEvent::TraceStringWithCopy(str)
 
 // By default, uint64 ID argument values are not mangled with the Process ID in
 // TRACE_EVENT_ASYNC macros. Use this macro to force Process ID mangling.
 #define TRACE_ID_MANGLE(id) \
-    WebCore::TraceEvent::TraceID::ForceMangle(id)
+    blink::TraceEvent::TraceID::ForceMangle(id)
 
 // By default, pointers are mangled with the Process ID in TRACE_EVENT_ASYNC
 // macros. Use this macro to prevent Process ID mangling.
 #define TRACE_ID_DONT_MANGLE(id) \
-    WebCore::TraceEvent::TraceID::DontMangle(id)
+    blink::TraceEvent::TraceID::DontMangle(id)
 
 // Records a pair of begin and end events called "name" for the current
 // scope, with 0, 1 or 2 associated arguments. If the category is not
 // enabled, then this does nothing.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
 #define TRACE_EVENT0(category, name) \
     INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name)
 #define TRACE_EVENT1(category, name, arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, arg1_name, arg1_val)
@@ skipping 327 matching lines @@
 // long-lived literal strings should be given as the category name. The returned
 // pointer can be held permanently in a local static for example. If the
 // unsigned char is non-zero, tracing is enabled. If tracing is enabled,
 // TRACE_EVENT_API_ADD_TRACE_EVENT can be called. It's OK if tracing is disabled
 // between the load of the tracing state and the call to
 // TRACE_EVENT_API_ADD_TRACE_EVENT, because this flag only provides an early out
 // for best performance when tracing is disabled.
 // const unsigned char*
 //     TRACE_EVENT_API_GET_CATEGORY_ENABLED(const char* category_name)
 #define TRACE_EVENT_API_GET_CATEGORY_ENABLED \
-    WebCore::EventTracer::getTraceCategoryEnabledFlag
+    blink::EventTracer::getTraceCategoryEnabledFlag
 
 // Add a trace event to the platform tracing system.
-// WebCore::TraceEvent::TraceEventHandle TRACE_EVENT_API_ADD_TRACE_EVENT(
+// blink::TraceEvent::TraceEventHandle TRACE_EVENT_API_ADD_TRACE_EVENT(
 //                    char phase,
 //                    const unsigned char* category_enabled,
 //                    const char* name,
 //                    unsigned long long id,
 //                    int num_args,
 //                    const char** arg_names,
 //                    const unsigned char* arg_types,
 //                    const unsigned long long* arg_values,
 //                    const RefPtr<ConvertableToTraceFormat>* convertableValues
 //                    unsigned char flags)
 #define TRACE_EVENT_API_ADD_TRACE_EVENT \
-    WebCore::EventTracer::addTraceEvent
+    blink::EventTracer::addTraceEvent
 
 // Set the duration field of a COMPLETE trace event.
 // void TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
-//     WebCore::TraceEvent::TraceEventHandle handle)
+//     blink::TraceEvent::TraceEventHandle handle)
 #define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION \
-    WebCore::EventTracer::updateTraceEventDuration
+    blink::EventTracer::updateTraceEventDuration
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Implementation detail: trace event macros create temporary variables
 // to keep instrumentation overhead low. These macros give each temporary
 // variable a unique name based on the line number to prevent name collissions.
 #define INTERNAL_TRACE_EVENT_UID3(a, b) \
     trace_event_unique_##a##b
 #define INTERNAL_TRACE_EVENT_UID2(a, b) \
     INTERNAL_TRACE_EVENT_UID3(a, b)
@@ skipping 11 matching lines @@
         INTERNALTRACEEVENTUID(categoryGroupEnabled) = \
             TRACE_EVENT_API_GET_CATEGORY_ENABLED(category); \
     }
 
 // Implementation detail: internal macro to create static category and add
 // event if the category is enabled.
 #define INTERNAL_TRACE_EVENT_ADD(phase, category, name, flags, ...) \
     do { \
         INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
         if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-            WebCore::TraceEvent::addTraceEvent( \
+            blink::TraceEvent::addTraceEvent( \
                 phase, INTERNALTRACEEVENTUID(categoryGroupEnabled), name, \
-                WebCore::TraceEvent::noEventId, flags, ##__VA_ARGS__); \
+                blink::TraceEvent::noEventId, flags, ##__VA_ARGS__); \
         } \
     } while (0)
 
 // Implementation detail: internal macro to create static category and add begin
 // event if the category is enabled. Also adds the end event when the scope
 // ends.
 #define INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, ...) \
     INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
-    WebCore::TraceEvent::ScopedTracer INTERNALTRACEEVENTUID(scopedTracer); \
+    blink::TraceEvent::ScopedTracer INTERNALTRACEEVENTUID(scopedTracer); \
     if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-        WebCore::TraceEvent::TraceEventHandle h = \
-            WebCore::TraceEvent::addTraceEvent( \
+        blink::TraceEvent::TraceEventHandle h = \
+            blink::TraceEvent::addTraceEvent( \
                 TRACE_EVENT_PHASE_COMPLETE, \
                 INTERNALTRACEEVENTUID(categoryGroupEnabled), \
-                name, WebCore::TraceEvent::noEventId, \
+                name, blink::TraceEvent::noEventId, \
                 TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__); \
         INTERNALTRACEEVENTUID(scopedTracer).initialize( \
             INTERNALTRACEEVENTUID(categoryGroupEnabled), name, h); \
     }
 
 // Implementation detail: internal macro to create static category and add
 // event if the category is enabled.
 #define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category, name, id, flags, \
                                          ...) \
     do { \
         INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
         if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
             unsigned char traceEventFlags = flags | TRACE_EVENT_FLAG_HAS_ID; \
-            WebCore::TraceEvent::TraceID traceEventTraceID( \
+            blink::TraceEvent::TraceID traceEventTraceID( \
                 id, &traceEventFlags); \
-            WebCore::TraceEvent::addTraceEvent( \
+            blink::TraceEvent::addTraceEvent( \
                 phase, INTERNALTRACEEVENTUID(categoryGroupEnabled), \
                 name, traceEventTraceID.data(), traceEventFlags, \
                 ##__VA_ARGS__); \
         } \
     } while (0)
 
 // Notes regarding the following definitions:
 // New values can be added and propagated to third party libraries, but existing
 // definitions must never be changed, because third party libraries may use old
 // definitions.
@@ skipping 31 matching lines @@
 #define TRACE_VALUE_TYPE_COPY_STRING  (static_cast<unsigned char>(7))
 #define TRACE_VALUE_TYPE_CONVERTABLE  (static_cast<unsigned char>(8))
 
 // These values must be in sync with base::debug::TraceLog::CategoryGroupEnabledFlags.
 #define ENABLED_FOR_RECORDING (1 << 0)
 #define ENABLED_FOR_EVENT_CALLBACK (1 << 2)
 
 #define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
     (*INTERNALTRACEEVENTUID(categoryGroupEnabled) & (ENABLED_FOR_RECORDING | ENABLED_FOR_EVENT_CALLBACK))
 
-namespace WebCore {
+namespace blink {
 
 namespace TraceEvent {
 
 // Specify these values when the corresponding argument of addTraceEvent is not
 // used.
 const int zeroNumArgs = 0;
 const unsigned long long noEventId = 0;
 
 // TraceID encapsulates an ID that can either be an integer or pointer. Pointers
 // are mangled with the Process ID so that they are unlikely to collide when the
@@ skipping 283 matching lines @@
     }
 
     ~SamplingStateScope()
     {
         SamplingStateScope<BucketNumber>::set(m_previousState);
     }
 
     // FIXME: Make load/store to traceSamplingState[] thread-safe and atomic.
     static inline const char* current()
     {
-        return reinterpret_cast<const char*>(*WebCore::traceSamplingState[BucketNumber]);
+        return reinterpret_cast<const char*>(*blink::traceSamplingState[BucketNumber]);
     }
     static inline void set(const char* categoryAndName)
     {
-        *WebCore::traceSamplingState[BucketNumber] = reinterpret_cast<long>(const_cast<char*>(categoryAndName));
+        *blink::traceSamplingState[BucketNumber] = reinterpret_cast<long>(const_cast<char*>(categoryAndName));
     }
 
 private:
     const char* m_previousState;
 };
 
 template<typename IDType> class TraceScopedTrackableObject {
     WTF_MAKE_NONCOPYABLE(TraceScopedTrackableObject);
 public:
     TraceScopedTrackableObject(const char* categoryGroup, const char* name, IDType id)
         : m_categoryGroup(categoryGroup), m_name(name), m_id(id)
     {
         TRACE_EVENT_OBJECT_CREATED_WITH_ID(m_categoryGroup, m_name, m_id);
     }
 
     ~TraceScopedTrackableObject()
     {
         TRACE_EVENT_OBJECT_DELETED_WITH_ID(m_categoryGroup, m_name, m_id);
     }
 
 private:
     const char* m_categoryGroup;
     const char* m_name;
     IDType m_id;
 };
 
 } // namespace TraceEvent
 
-} // namespace WebCore
+} // namespace blink
 
 #endif