iwyu: Include stringprintf.h where appropriate, part 1.

gpu/common/gpu_trace_event.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/common/gpu_trace_event.h"
 
 #include "base/format_macros.h"
 #include "base/process_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/time.h"
 
 #define USE_UNRELIABLE_NOW
 
-using namespace base;
-
 namespace gpu {
 
 // Controls the number of trace events we will buffer in-memory
 // before throwing them away.
 #define TRACE_EVENT_BUFFER_SIZE 500000
 #define TRACE_EVENT_BATCH_SIZE 1000
 
 #define TRACE_EVENT_MAX_CATEGORIES 42
 
 static TraceCategory g_categories[TRACE_EVENT_MAX_CATEGORIES];
@@ skipping 143 matching lines @@
 void TraceEvent::AppendAsJSON(std::string* out) const {
   int nargs = 0;
   for (int i = 0; i < TRACE_MAX_NUM_ARGS; ++i) {
     if (argNames[i] == NULL)
       break;
     nargs += 1;
   }
 
   const char* phaseStr = GetPhaseStr(phase);
   int64 time_int64 = timestamp.ToInternalValue();
-  StringAppendF(out,
+  base::StringAppendF(
+      out,
       "{\"cat\":\"%s\",\"pid\":%i,\"tid\":%i,\"ts\":%lld,"
       "\"ph\":\"%s\",\"name\":\"%s\",\"args\":{",
       category->name(),
       static_cast<int>(processId),
       static_cast<int>(threadId),
       static_cast<long long>(time_int64),
       phaseStr,
       name);
   for (int  i = 0; i < nargs; ++i) {
     if (i > 0)
@@ skipping 21 matching lines @@
 TraceLog::TraceLog()
     : enabled_(false)
 {
   logged_events_.reserve(1024);
 }
 
 TraceLog::~TraceLog() {
 }
 
 TraceCategory* TraceLog::GetCategory(const char* name) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   for (int i = 0; i < g_category_index; i++) {
     if (strcmp(g_categories[i].name(), name) == 0)
       return &g_categories[i];
   }
   CHECK(g_category_index < TRACE_EVENT_MAX_CATEGORIES) <<
       "must increase TRACE_EVENT_MAX_CATEGORIES";
   int new_index = g_category_index++;
   g_categories[new_index].set(name, enabled_);
   return &g_categories[new_index];
 }
 
 void TraceLog::SetEnabled(bool enabled) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   if (enabled == enabled_)
     return;
   if (enabled) {
     // Enable all categories.
     enabled_ = true;
     for (int i = 0; i < g_category_index; i++) {
       base::subtle::NoBarrier_Store(&g_categories[i].enabled_,
                                     static_cast<base::subtle::Atomic32>(1));
     }
   } else {
     // Disable all categories.
     for (int i = 0; i < g_category_index; i++) {
       base::subtle::NoBarrier_Store(&g_categories[i].enabled_,
                                     static_cast<base::subtle::Atomic32>(0));
     }
     enabled_ = false;
     FlushWithLockAlreadyHeld();
   }
 }
 
 float TraceLog::GetBufferPercentFull() const {
   return (float)((double)logged_events_.size()/(double)TRACE_EVENT_BUFFER_SIZE);
 }
 
 void TraceLog::SetOutputCallback(TraceLog::OutputCallback* cb) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   if (enabled_) {
     FlushWithLockAlreadyHeld();
   }
   output_callback_.reset(cb);
 }
 
 void TraceLog::SetBufferFullCallback(TraceLog::BufferFullCallback* cb) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   buffer_full_callback_.reset(cb);
 }
 
 void TraceLog::AddRemotelyCollectedData(const std::string& json_events) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   if (output_callback_.get())
     output_callback_->Run(json_events);
 }
 
 void TraceLog::Flush() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   FlushWithLockAlreadyHeld();
 }
 
 void TraceLog::FlushWithLockAlreadyHeld() {
   if (output_callback_.get() && logged_events_.size()) {
     for (size_t i = 0; i < logged_events_.size(); i += TRACE_EVENT_BATCH_SIZE) {
       std::string json_events;
       TraceEvent::AppendAsJSON(&json_events, logged_events_,
                                i, TRACE_EVENT_BATCH_SIZE);
       output_callback_->Run(json_events);
     }
   }
   logged_events_.erase(logged_events_.begin(), logged_events_.end());
 }
 
 void TraceLog::AddTraceEvent(TraceEventPhase phase,
     const char* file, int line,
     TraceCategory* category,
     const char* name,
     const char* arg1name, TraceValue arg1val,
     const char* arg2name, TraceValue arg2val) {
   DCHECK(file && name);
 #ifdef USE_UNRELIABLE_NOW
-  TimeTicks now = TimeTicks::HighResNow();
+  base::TimeTicks now = base::TimeTicks::HighResNow();
 #else
-  TimeTicks now = TimeTicks::Now();
+  base::TimeTicks now = base::TimeTicks::Now();
 #endif
   //static_cast<unsigned long>(base::GetCurrentProcId()),
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   if (logged_events_.size() >= TRACE_EVENT_BUFFER_SIZE)
     return;
   logged_events_.push_back(TraceEvent());
   TraceEvent& event = logged_events_.back();
   event.processId = static_cast<unsigned long>(base::GetCurrentProcId());
-  event.threadId = PlatformThread::CurrentId();
+  event.threadId = base::PlatformThread::CurrentId();
   event.timestamp = now;
   event.phase = phase;
   event.category = category;
   event.name = name;
   event.argNames[0] = arg1name;
   event.argValues[0] = arg1val;
   event.argNames[1] = arg2name;
   event.argValues[1] = arg2val;
   COMPILE_ASSERT(TRACE_MAX_NUM_ARGS == 2, TraceEvent_arc_count_out_of_sync);
   if (logged_events_.size() == TRACE_EVENT_BUFFER_SIZE &&
       buffer_full_callback_.get())
     buffer_full_callback_->Run();
 }
 
 }  // namespace gpu