Revert 84486 - Merge gpu_trace_event back into base/debug/trace_event.Initial land attempt at htt...

base/debug/trace_event_win_unittest.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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/debug/trace_event.h"
 
 #include <strstream>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/file_util.h"
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_win.h"
 #include "base/win/event_trace_consumer.h"
 #include "base/win/event_trace_controller.h"
-#include "base/win/event_trace_provider.h"
 #include "base/win/windows_version.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <initguid.h>  // NOLINT - must be last include.
 
 namespace base {
 namespace debug {
 
 namespace {
 
@@ skipping 53 matching lines @@
                     event->MofLength,
                     event->MofData);
   }
 
  private:
   static TestEventConsumer* current_;
 };
 
 TestEventConsumer* TestEventConsumer::current_ = NULL;
 
-class TraceEventWinTest: public testing::Test {
+class TraceEventTest: public testing::Test {
  public:
-  TraceEventWinTest() {
+  TraceEventTest() {
   }
 
   void SetUp() {
     bool is_xp = win::GetVersion() < base::win::VERSION_VISTA;
 
     if (is_xp) {
       // Tear down any dangling session from an earlier failing test.
       EtwTraceProperties ignore;
       EtwTraceController::Stop(kTestSessionName, &ignore);
     }
 
     // Resurrect and initialize the TraceLog singleton instance.
     // On Vista and better, we need the provider registered before we
     // start the private, in-proc session, but on XP we need the global
     // session created and the provider enabled before we register our
     // provider.
-    TraceEventETWProvider* tracelog = NULL;
+    TraceLog* tracelog = NULL;
     if (!is_xp) {
-      TraceEventETWProvider::Resurrect();
-      tracelog = TraceEventETWProvider::GetInstance();
+      TraceLog::Resurrect();
+      tracelog = TraceLog::GetInstance();
       ASSERT_TRUE(tracelog != NULL);
       ASSERT_FALSE(tracelog->IsTracing());
     }
 
     // Create the log file.
     ASSERT_TRUE(file_util::CreateTemporaryFile(&log_file_));
 
     // Create a private log session on the file.
     EtwTraceProperties prop;
     ASSERT_HRESULT_SUCCEEDED(prop.SetLoggerFileName(log_file_.value().c_str()));
@@ skipping 14 matching lines @@
     p.FlushTimer = 1;  // 1 second flush lag.
     ASSERT_HRESULT_SUCCEEDED(controller_.Start(kTestSessionName, &prop));
 
     // Enable the TraceLog provider GUID.
     ASSERT_HRESULT_SUCCEEDED(
         controller_.EnableProvider(kChromeTraceProviderName,
                                    TRACE_LEVEL_INFORMATION,
                                    0));
 
     if (is_xp) {
-      TraceEventETWProvider::Resurrect();
-      tracelog = TraceEventETWProvider::GetInstance();
+      TraceLog::Resurrect();
+      tracelog = TraceLog::GetInstance();
     }
     ASSERT_TRUE(tracelog != NULL);
     EXPECT_TRUE(tracelog->IsTracing());
   }
 
   void TearDown() {
     EtwTraceProperties prop;
     if (controller_.session() != 0)
       EXPECT_HRESULT_SUCCEEDED(controller_.Stop(&prop));
 
@@ skipping 41 matching lines @@
   // We want our singleton torn down after each test.
   ShadowingAtExitManager at_exit_manager_;
   EtwTraceController controller_;
   FilePath log_file_;
   TestEventConsumer consumer_;
 };
 
 }  // namespace
 
 
-TEST_F(TraceEventWinTest, TraceLog) {
+TEST_F(TraceEventTest, TraceLog) {
   ExpectPlayLog();
 
   // The events should arrive in the same sequence as the expects.
   InSequence in_sequence;
 
   // Full argument version, passing lengths explicitly.
-  TraceEventETWProvider::Trace(kName,
+  TraceLog::Trace(kName,
                         strlen(kName),
-                        base::debug::TRACE_EVENT_PHASE_BEGIN,
+                        TraceLog::EVENT_BEGIN,
                         kId,
                         kExtra,
                         strlen(kExtra));
 
   ExpectEvent(kTraceEventClass32,
               kTraceEventTypeBegin,
               kName, strlen(kName),
               kId,
               kExtra, strlen(kExtra));
 
   // Const char* version.
-  TraceEventETWProvider::Trace(static_cast<const char*>(kName),
-                        base::debug::TRACE_EVENT_PHASE_END,
+  TraceLog::Trace(static_cast<const char*>(kName),
+                        TraceLog::EVENT_END,
                         kId,
                         static_cast<const char*>(kExtra));
 
   ExpectEvent(kTraceEventClass32,
               kTraceEventTypeEnd,
               kName, strlen(kName),
               kId,
               kExtra, strlen(kExtra));
 
   // std::string extra version.
-  TraceEventETWProvider::Trace(static_cast<const char*>(kName),
-                        base::debug::TRACE_EVENT_PHASE_INSTANT,
+  TraceLog::Trace(static_cast<const char*>(kName),
+                        TraceLog::EVENT_INSTANT,
                         kId,
                         std::string(kExtra));
 
   ExpectEvent(kTraceEventClass32,
               kTraceEventTypeInstant,
               kName, strlen(kName),
               kId,
               kExtra, strlen(kExtra));
 
 
   // Test for sanity on NULL inputs.
-  TraceEventETWProvider::Trace(NULL,
+  TraceLog::Trace(NULL,
                         0,
-                        base::debug::TRACE_EVENT_PHASE_BEGIN,
+                        TraceLog::EVENT_BEGIN,
                         kId,
                         NULL,
                         0);
 
   ExpectEvent(kTraceEventClass32,
               kTraceEventTypeBegin,
               kEmpty, 0,
               kId,
               kEmpty, 0);
 
-  TraceEventETWProvider::Trace(NULL,
+  TraceLog::Trace(NULL,
                         -1,
-                        base::debug::TRACE_EVENT_PHASE_END,
+                        TraceLog::EVENT_END,
                         kId,
                         NULL,
                         -1);
 
   ExpectEvent(kTraceEventClass32,
               kTraceEventTypeEnd,
               kEmpty, 0,
               kId,
               kEmpty, 0);
 
   PlayLog();
 }
 
-TEST_F(TraceEventWinTest, Macros) {
+TEST_F(TraceEventTest, Macros) {
   ExpectPlayLog();
 
   // The events should arrive in the same sequence as the expects.
   InSequence in_sequence;
 
-  TRACE_EVENT_BEGIN_ETW(kName, kId, kExtra);
+  TRACE_EVENT_BEGIN(kName, kId, kExtra);
   ExpectEvent(kTraceEventClass32,
               kTraceEventTypeBegin,
               kName, strlen(kName),
               kId,
               kExtra, strlen(kExtra));
 
-  TRACE_EVENT_END_ETW(kName, kId, kExtra);
+  TRACE_EVENT_END(kName, kId, kExtra);
   ExpectEvent(kTraceEventClass32,
               kTraceEventTypeEnd,
               kName, strlen(kName),
               kId,
               kExtra, strlen(kExtra));
 
-  TRACE_EVENT_INSTANT_ETW(kName, kId, kExtra);
+  TRACE_EVENT_INSTANT(kName, kId, kExtra);
   ExpectEvent(kTraceEventClass32,
               kTraceEventTypeInstant,
               kName, strlen(kName),
               kId,
               kExtra, strlen(kExtra));
 
   PlayLog();
 }
 
 }  // namespace debug
 }  // namespace base