Fix more remaining FilePath -> base::FilePath.

base/win/event_trace_consumer_unittest.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.
 //
 // 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/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/process.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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include <initguid.h>  // NOLINT - has to be last
 
+namespace base {
+namespace win {
+
 namespace {
 
-using base::win::EtwMofEvent;
-using base::win::EtwTraceController;
-using base::win::EtwTraceConsumerBase;
-using base::win::EtwTraceProperties;
-using base::win::EtwTraceProvider;
-
 typedef std::list<EVENT_TRACE> EventQueue;
 
 class TestConsumer: public EtwTraceConsumerBase<TestConsumer> {
  public:
   TestConsumer() {
     sank_event_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
     ClearQueue();
   }
 
   ~TestConsumer() {
@@ skipping 19 matching lines @@
       back.MofData = new char[event->MofLength];
       memcpy(back.MofData, event->MofData, event->MofLength);
     }
   }
 
   static void ProcessEvent(EVENT_TRACE* event) {
     EnqueueEvent(event);
     ::SetEvent(sank_event_.Get());
   }
 
-  static base::win::ScopedHandle sank_event_;
+  static ScopedHandle sank_event_;
   static EventQueue events_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestConsumer);
 };
 
-base::win::ScopedHandle TestConsumer::sank_event_;
+ScopedHandle TestConsumer::sank_event_;
 EventQueue TestConsumer::events_;
 
 class EtwTraceConsumerBaseTest: public testing::Test {
  public:
   EtwTraceConsumerBaseTest()
-      : session_name_(base::StringPrintf(L"TestSession-%d",
-                                         base::Process::Current().pid())) {
+      : session_name_(StringPrintf(L"TestSession-%d",
+                                   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_));
   }
@@ skipping 101 matching lines @@
       return HRESULT_FROM_WIN32(::GetLastError());
 
     DWORD exit_code = 0;
     if (::GetExitCodeThread(consumer_thread_, &exit_code))
       return exit_code;
 
     return HRESULT_FROM_WIN32(::GetLastError());
   }
 
   TestConsumer consumer_;
-  base::win::ScopedHandle consumer_ready_;
-  base::win::ScopedHandle consumer_thread_;
+  ScopedHandle consumer_ready_;
+  ScopedHandle consumer_thread_;
 };
 
 }  // namespace
 
 TEST_F(EtwTraceConsumerRealtimeTest, ConsumerReturnsWhenSessionClosed) {
   EtwTraceController controller;
 
   HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(),
                                                100 * 1024);
   if (hr == E_ACCESSDENIED) {
@@ skipping 128 matching lines @@
 
     // We should now have the event in the queue.
     if (events_.empty())
       return E_FAIL;
 
     *trace = &events_.back();
     return S_OK;
   }
 
   EventQueue events_;
-  base::ScopedTempDir temp_dir_;
+  ScopedTempDir temp_dir_;
   FilePath temp_file_;
 };
 
 }  // namespace
 
 
 TEST_F(EtwTraceConsumerDataTest, RoundTrip) {
   EtwMofEvent<1> event(kTestEventType, 1, TRACE_LEVEL_ERROR);
 
   static const char kData[] = "This is but test data";
   event.fields[0].DataPtr = reinterpret_cast<ULONG64>(kData);
   event.fields[0].Length = sizeof(kData);
 
   PEVENT_TRACE trace = NULL;
   HRESULT hr = RoundTripEvent(&event.header, &trace);
   if (hr == E_ACCESSDENIED) {
     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));
 }
+
+}  // namespace win
+}  // namespace base