Make ETW unittests shardable to quench flakyness on trybots.

Use a per-process ETW session name, and a per-test provider GUID to avoid name collisions under test sharding on trybots.

R=thakis@chromium.org,jar@chromium.org
BUG=111240
TEST=No more spurious failures on trybots.


Review URL: http://codereview.chromium.org/9288075

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@119544 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 110 insertions, 54 deletions

diff --git a/base/win/event_trace_consumer_unittest.cc b/base/win/event_trace_consumer_unittest.cc
index efbfdf9..dbf4ba9 100644
--- a/base/win/event_trace_consumer_unittest.cc
+++ b/base/win/event_trace_consumer_unittest.cc
@@ -1,16 +1,21 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 //
-// Unit tests for event trace consumer_ base class.
+// Unit tests for event trace consumer base class.
 #include "base/win/event_trace_consumer.h"
 
 #include <list>
 
+#include <objbase.h>
+
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/process.h"
+#include "base/scoped_temp_dir.h"
+#include "base/stringprintf.h"
 #include "base/win/event_trace_controller.h"
 #include "base/win/event_trace_provider.h"
 #include "base/win/scoped_handle.h"
@@ -75,14 +80,31 @@ class TestConsumer: public EtwTraceConsumerBase<TestConsumer> {
 base::win::ScopedHandle TestConsumer::sank_event_;
 EventQueue TestConsumer::events_;
 
-const wchar_t* const kTestSessionName = L"TestLogSession";
-
 class EtwTraceConsumerBaseTest: public testing::Test {
  public:
+  EtwTraceConsumerBaseTest()
+      : session_name_(base::StringPrintf(L"TestSession-%d",
+                                         base::Process::Current().pid())) {
+  }
+
   virtual void SetUp() {
+    // Cleanup any potentially dangling sessions.
+    EtwTraceProperties ignore;
+    EtwTraceController::Stop(session_name_.c_str(), &ignore);
+
+    // Allocate a new GUID for each provider test.
+    ASSERT_HRESULT_SUCCEEDED(::CoCreateGuid(&test_provider_));
+  }
+
+  virtual void TearDown() {
+    // Cleanup any potentially danging sessions.
     EtwTraceProperties ignore;
-    EtwTraceController::Stop(kTestSessionName, &ignore);
+    EtwTraceController::Stop(session_name_.c_str(), &ignore);
   }
+
+ protected:
+  GUID test_provider_;
+  std::wstring session_name_;
 };
 
 }  // namespace
@@ -94,26 +116,33 @@ TEST_F(EtwTraceConsumerBaseTest, Initialize) {
 TEST_F(EtwTraceConsumerBaseTest, OpenRealtimeSucceedsWhenNoSession) {
   TestConsumer consumer_;
 
-  ASSERT_HRESULT_SUCCEEDED(consumer_.OpenRealtimeSession(kTestSessionName));
+  ASSERT_HRESULT_SUCCEEDED(
+      consumer_.OpenRealtimeSession(session_name_.c_str()));
 }
 
 TEST_F(EtwTraceConsumerBaseTest, ConsumerImmediateFailureWhenNoSession) {
   TestConsumer consumer_;
 
-  ASSERT_HRESULT_SUCCEEDED(consumer_.OpenRealtimeSession(kTestSessionName));
+  ASSERT_HRESULT_SUCCEEDED(
+      consumer_.OpenRealtimeSession(session_name_.c_str()));
   ASSERT_HRESULT_FAILED(consumer_.Consume());
 }
 
 namespace {
 
-class EtwTraceConsumerRealtimeTest: public testing::Test {
+class EtwTraceConsumerRealtimeTest: public EtwTraceConsumerBaseTest {
  public:
   virtual void SetUp() {
-    ASSERT_HRESULT_SUCCEEDED(consumer_.OpenRealtimeSession(kTestSessionName));
+    EtwTraceConsumerBaseTest::SetUp();
+
+    ASSERT_HRESULT_SUCCEEDED(
+        consumer_.OpenRealtimeSession(session_name_.c_str()));
   }
 
   virtual void TearDown() {
     consumer_.Close();
+
+    EtwTraceConsumerBaseTest::TearDown();
   }
 
   DWORD ConsumerThread() {
@@ -177,15 +206,18 @@ class EtwTraceConsumerRealtimeTest: public testing::Test {
   }
 
   TestConsumer consumer_;
+  GUID test_provider_;
   base::win::ScopedHandle consumer_ready_;
   base::win::ScopedHandle consumer_thread_;
 };
+
 }  // namespace
 
 TEST_F(EtwTraceConsumerRealtimeTest, ConsumerReturnsWhenSessionClosed) {
   EtwTraceController controller;
 
-  HRESULT hr = controller.StartRealtimeSession(kTestSessionName, 100 * 1024);
+  HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(),
+                                               100 * 1024);
   if (hr == E_ACCESSDENIED) {
     VLOG(1) << "You must be an administrator to run this test on Vista";
     return;
@@ -205,10 +237,6 @@ TEST_F(EtwTraceConsumerRealtimeTest, ConsumerReturnsWhenSessionClosed) {
 
 namespace {
 
-// {036B8F65-8DF3-46e4-ABFC-6985C43D59BA}
-DEFINE_GUID(kTestProvider,
-  0x36b8f65, 0x8df3, 0x46e4, 0xab, 0xfc, 0x69, 0x85, 0xc4, 0x3d, 0x59, 0xba);
-
 // {57E47923-A549-476f-86CA-503D57F59E62}
 DEFINE_GUID(kTestEventType,
   0x57e47923, 0xa549, 0x476f, 0x86, 0xca, 0x50, 0x3d, 0x57, 0xf5, 0x9e, 0x62);
@@ -217,16 +245,17 @@ DEFINE_GUID(kTestEventType,
 
 TEST_F(EtwTraceConsumerRealtimeTest, ConsumeEvent) {
   EtwTraceController controller;
-  HRESULT hr = controller.StartRealtimeSession(kTestSessionName, 100 * 1024);
+  HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(),
+                                               100 * 1024);
   if (hr == E_ACCESSDENIED) {
     VLOG(1) << "You must be an administrator to run this test on Vista";
     return;
   }
 
-  ASSERT_HRESULT_SUCCEEDED(controller.EnableProvider(kTestProvider,
+  ASSERT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_,
       TRACE_LEVEL_VERBOSE, 0xFFFFFFFF));
 
-  EtwTraceProvider provider(kTestProvider);
+  EtwTraceProvider provider(test_provider_);
   ASSERT_EQ(ERROR_SUCCESS, provider.Register());
 
   // Start the consumer_.
@@ -248,43 +277,46 @@ namespace {
 
 // We run events through a file session to assert that
 // the content comes through.
-class EtwTraceConsumerDataTest: public testing::Test {
+class EtwTraceConsumerDataTest: public EtwTraceConsumerBaseTest {
  public:
   EtwTraceConsumerDataTest() {
   }
 
   virtual void SetUp() {
     EtwTraceProperties prop;
-    EtwTraceController::Stop(kTestSessionName, &prop);
-    // Construct a temp file name.
-    ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file_));
+    EtwTraceController::Stop(session_name_.c_str(), &prop);
+
+    // Create a temp dir for this test.
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+    // Construct a temp file name in our dir.
+    temp_file_ = temp_dir_.path().Append(L"test.etl");
   }
 
   virtual void TearDown() {
     EXPECT_TRUE(file_util::Delete(temp_file_, false));
-    EtwTraceProperties ignore;
-    EtwTraceController::Stop(kTestSessionName, &ignore);
+
+    EtwTraceConsumerBaseTest::TearDown();
   }
 
   HRESULT LogEventToTempSession(PEVENT_TRACE_HEADER header) {
     EtwTraceController controller;
 
     // Set up a file session.
-    HRESULT hr = controller.StartFileSession(kTestSessionName,
+    HRESULT hr = controller.StartFileSession(session_name_.c_str(),
                                              temp_file_.value().c_str());
     if (FAILED(hr))
       return hr;
 
     // Enable our provider.
-    EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(kTestProvider,
+    EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_,
         TRACE_LEVEL_VERBOSE, 0xFFFFFFFF));
 
-    EtwTraceProvider provider(kTestProvider);
+    EtwTraceProvider provider(test_provider_);
     // Then register our provider, means we get a session handle immediately.
     EXPECT_EQ(ERROR_SUCCESS, provider.Register());
     // Trace the event, it goes to the temp file.
     EXPECT_EQ(ERROR_SUCCESS, provider.Log(header));
-    EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(kTestProvider));
+    EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(test_provider_));
     EXPECT_HRESULT_SUCCEEDED(provider.Unregister());
     EXPECT_HRESULT_SUCCEEDED(controller.Flush(NULL));
     EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
@@ -323,6 +355,7 @@ class EtwTraceConsumerDataTest: public testing::Test {
   }
 
   EventQueue events_;
+  ScopedTempDir temp_dir_;
   FilePath temp_file_;
 };
 
@@ -342,6 +375,7 @@ TEST_F(EtwTraceConsumerDataTest, RoundTrip) {
     VLOG(1) << "You must be an administrator to run this test on Vista";
     return;
   }
+  ASSERT_HRESULT_SUCCEEDED(hr) << "RoundTripEvent failed";
   ASSERT_TRUE(NULL != trace);
   ASSERT_EQ(sizeof(kData), trace->MofLength);
   ASSERT_STREQ(kData, reinterpret_cast<const char*>(trace->MofData));
diff --git a/base/win/event_trace_controller_unittest.cc b/base/win/event_trace_controller_unittest.cc
index 78969d8..2e3a403 100644
--- a/base/win/event_trace_controller_unittest.cc
+++ b/base/win/event_trace_controller_unittest.cc
@@ -1,15 +1,18 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 //
 // Unit tests for event trace controller.
 
-#include <initguid.h>  // NOLINT.
+#include <objbase.h>
+#include <initguid.h>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/process.h"
 #include "base/scoped_temp_dir.h"
+#include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/win/event_trace_controller.h"
 #include "base/win/event_trace_provider.h"
@@ -22,12 +25,6 @@ using base::win::EtwTraceController;
 using base::win::EtwTraceProvider;
 using base::win::EtwTraceProperties;
 
-const wchar_t kTestSessionName[] = L"TestLogSession";
-
-// {0D236A42-CD18-4e3d-9975-DCEEA2106E05}
-DEFINE_GUID(kTestProvider,
-    0xd236a42, 0xcd18, 0x4e3d, 0x99, 0x75, 0xdc, 0xee, 0xa2, 0x10, 0x6e, 0x5);
-
 DEFINE_GUID(kGuidNull,
     0x0000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0);
 
@@ -60,12 +57,6 @@ class TestingProvider: public EtwTraceProvider {
 
 }  // namespace
 
-TEST(EtwTraceTest, Cleanup) {
-  // Clean up potential leftover sessions from previous unsuccessful runs.
-  EtwTraceProperties ignore;
-  EtwTraceController::Stop(kTestSessionName, &ignore);
-}
-
 TEST(EtwTracePropertiesTest, Initialization) {
   EtwTraceProperties prop;
 
@@ -115,38 +106,68 @@ TEST(EtwTracePropertiesTest, Strings) {
   ASSERT_HRESULT_FAILED(prop.SetLoggerName(name2.c_str()));
 }
 
-TEST(EtwTraceControllerTest, Initialize) {
+namespace {
+
+class EtwTraceControllerTest : public testing::Test {
+ public:
+  EtwTraceControllerTest() : session_name_(
+      base::StringPrintf(L"TestSession-%d", base::Process::Current().pid())) {
+  }
+
+  virtual void SetUp() {
+    EtwTraceProperties ignore;
+    EtwTraceController::Stop(session_name_.c_str(), &ignore);
+
+    // Allocate a new provider name GUID for each test.
+    ASSERT_HRESULT_SUCCEEDED(::CoCreateGuid(&test_provider_));
+  }
+
+  virtual void TearDown() {
+    EtwTraceProperties prop;
+    EtwTraceController::Stop(session_name_.c_str(), &prop);
+  }
+
+ protected:
+  GUID test_provider_;
+  std::wstring session_name_;
+};
+
+}  // namespace
+
+TEST_F(EtwTraceControllerTest, Initialize) {
   EtwTraceController controller;
 
   EXPECT_EQ(NULL, controller.session());
   EXPECT_STREQ(L"", controller.session_name());
 }
 
-TEST(EtwTraceControllerTest, StartRealTimeSession) {
+
+TEST_F(EtwTraceControllerTest, StartRealTimeSession) {
   EtwTraceController controller;
 
-  HRESULT hr = controller.StartRealtimeSession(kTestSessionName, 100 * 1024);
+  HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(),
+                                               100 * 1024);
   if (hr == E_ACCESSDENIED) {
     VLOG(1) << "You must be an administrator to run this test on Vista";
     return;
   }
 
   EXPECT_TRUE(NULL != controller.session());
-  EXPECT_STREQ(kTestSessionName, controller.session_name());
+  EXPECT_STREQ(session_name_.c_str(), controller.session_name());
 
   EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
   EXPECT_EQ(NULL, controller.session());
   EXPECT_STREQ(L"", controller.session_name());
 }
 
-TEST(EtwTraceControllerTest, StartFileSession) {
+TEST_F(EtwTraceControllerTest, StartFileSession) {
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath temp;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir.path(), &temp));
 
   EtwTraceController controller;
-  HRESULT hr = controller.StartFileSession(kTestSessionName,
+  HRESULT hr = controller.StartFileSession(session_name_.c_str(),
                                            temp.value().c_str());
   if (hr == E_ACCESSDENIED) {
     VLOG(1) << "You must be an administrator to run this test on Vista";
@@ -155,7 +176,7 @@ TEST(EtwTraceControllerTest, StartFileSession) {
   }
 
   EXPECT_TRUE(NULL != controller.session());
-  EXPECT_STREQ(kTestSessionName, controller.session_name());
+  EXPECT_STREQ(session_name_.c_str(), controller.session_name());
 
   EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
   EXPECT_EQ(NULL, controller.session());
@@ -163,20 +184,21 @@ TEST(EtwTraceControllerTest, StartFileSession) {
   file_util::Delete(temp, false);
 }
 
-TEST(EtwTraceControllerTest, EnableDisable) {
-  TestingProvider provider(kTestProvider);
+TEST_F(EtwTraceControllerTest, EnableDisable) {
+  TestingProvider provider(test_provider_);
 
   EXPECT_EQ(ERROR_SUCCESS, provider.Register());
   EXPECT_EQ(NULL, provider.session_handle());
 
   EtwTraceController controller;
-  HRESULT hr = controller.StartRealtimeSession(kTestSessionName, 100 * 1024);
+  HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(),
+                                               100 * 1024);
   if (hr == E_ACCESSDENIED) {
     VLOG(1) << "You must be an administrator to run this test on Vista";
     return;
   }
 
-  EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(kTestProvider,
+  EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_,
                            TRACE_LEVEL_VERBOSE, kTestProviderFlags));
 
   provider.WaitForCallback();
@@ -184,7 +206,7 @@ TEST(EtwTraceControllerTest, EnableDisable) {
   EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level());
   EXPECT_EQ(kTestProviderFlags, provider.enable_flags());
 
-  EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(kTestProvider));
+  EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(test_provider_));
 
   provider.WaitForCallback();
 
@@ -194,7 +216,7 @@ TEST(EtwTraceControllerTest, EnableDisable) {
   EXPECT_EQ(ERROR_SUCCESS, provider.Unregister());
 
   // Enable the provider again, before registering.
-  EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(kTestProvider,
+  EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_,
                            TRACE_LEVEL_VERBOSE, kTestProviderFlags));
 
   // Register the provider again, the settings above