Fix gpu_video_decode_accelerator include order by renaming enum with X11 name collision

base/tracked_objects.cc

 // Copyright (c) 2012 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 "base/tracked_objects.h"
 
 #include <limits.h>
 #include <stdlib.h>
 
 #include "base/atomicops.h"
@@ skipping 16 matching lines @@
 
 namespace tracked_objects {
 
 namespace {
 // When ThreadData is first initialized, should we start in an ACTIVE state to
 // record all of the startup-time tasks, or should we start up DEACTIVATED, so
 // that we only record after parsing the command line flag --enable-tracking.
 // Note that the flag may force either state, so this really controls only the
 // period of time up until that flag is parsed.  If there is no flag seen, then
 // this state may prevail for much or all of the process lifetime.
-const ThreadData::Status kInitialStartupState = ThreadData::PROFILING_ACTIVE;
+const ThreadData::ThreadStatus kInitialStartupState =
+    ThreadData::PROFILING_ACTIVE;
 
 // Possible states of the profiler timing enabledness.
 enum {
   UNDEFINED_TIMING,
   ENABLED_TIMING,
   DISABLED_TIMING,
 };
 
 // State of the profiler timing enabledness.
 base::subtle::Atomic32 g_profiler_timing_enabled = UNDEFINED_TIMING;
@@ skipping 650 matching lines @@
   ++incarnation_counter_;
 
   // The lock is not critical for setting status_, but it doesn't hurt.  It also
   // ensures that if we have a racy initialization, that we'll bail as soon as
   // we get the lock earlier in this method.
   base::subtle::Release_Store(&status_, kInitialStartupState);
   DCHECK(base::subtle::NoBarrier_Load(&status_) != UNINITIALIZED);
 }
 
 // static
-void ThreadData::InitializeAndSetTrackingStatus(Status status) {
+void ThreadData::InitializeAndSetTrackingStatus(ThreadStatus status) {
   DCHECK_GE(status, DEACTIVATED);
   DCHECK_LE(status, PROFILING_ACTIVE);
 
   Initialize();  // No-op if already initialized.
 
   if (status > DEACTIVATED)
     status = PROFILING_ACTIVE;
   base::subtle::Release_Store(&status_, status);
 }
 
 // static
-ThreadData::Status ThreadData::status() {
-  return static_cast<ThreadData::Status>(base::subtle::Acquire_Load(&status_));
+ThreadData::ThreadStatus ThreadData::status() {
+  return static_cast<ThreadData::ThreadStatus>(
+      base::subtle::Acquire_Load(&status_));
 }
 
 // static
 bool ThreadData::TrackingStatus() {
   return base::subtle::Acquire_Load(&status_) > DEACTIVATED;
 }
 
 // static
 void ThreadData::EnableProfilerTiming() {
   base::subtle::NoBarrier_Store(&g_profiler_timing_enabled, ENABLED_TIMING);
@@ skipping 236 matching lines @@
 #endif
 }
 
 ProcessDataSnapshot::ProcessDataSnapshot(const ProcessDataSnapshot& other) =
     default;
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects