Fix "unreachable code" warnings (MSVC warning 4702) in base/.

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>
@@ skipping 25 matching lines @@
     sank_event_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
     ClearQueue();
   }
 
   ~TestConsumer() {
     ClearQueue();
     sank_event_.Close();
   }
 
   void ClearQueue() {
-    EventQueue::const_iterator it(events_.begin()), end(events_.end());
-
-    for (; it != end; ++it) {
-      delete [] it->MofData;
+    for (EventQueue::const_iterator it(events_.begin()), end(events_.end());
+         it != end; ++it) {
+      delete[] it->MofData;
     }
 
     events_.clear();
   }
 
   static void EnqueueEvent(EVENT_TRACE* event) {
     events_.push_back(*event);
     EVENT_TRACE& back = events_.back();
 
-    if (NULL != event->MofData && 0 != event->MofLength) {
+    if (event->MofData != NULL && event->MofLength != 0) {

[Peter Kasting, 2014/03/18 03:17:09]

(From our style guide: "Prefer (foo == 0) to (0 == foo).")

       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());
   }
 
@@ skipping 35 matching lines @@
 };
 
 }  // namespace
 
 TEST_F(EtwTraceConsumerBaseTest, Initialize) {
   TestConsumer consumer_;
 }
 
 TEST_F(EtwTraceConsumerBaseTest, OpenRealtimeSucceedsWhenNoSession) {
   TestConsumer consumer_;
-
   ASSERT_HRESULT_SUCCEEDED(
       consumer_.OpenRealtimeSession(session_name_.c_str()));
 }
 
 TEST_F(EtwTraceConsumerBaseTest, ConsumerImmediateFailureWhenNoSession) {
   TestConsumer consumer_;
-
   ASSERT_HRESULT_SUCCEEDED(
       consumer_.OpenRealtimeSession(session_name_.c_str()));
   ASSERT_HRESULT_FAILED(consumer_.Consume());
 }
 
 namespace {
 
 class EtwTraceConsumerRealtimeTest: public EtwTraceConsumerBaseTest {
  public:
   virtual void SetUp() {
     EtwTraceConsumerBaseTest::SetUp();
-
     ASSERT_HRESULT_SUCCEEDED(
         consumer_.OpenRealtimeSession(session_name_.c_str()));
   }
 
   virtual void TearDown() {
     consumer_.Close();
-
     EtwTraceConsumerBaseTest::TearDown();
   }
 
   DWORD ConsumerThread() {
     ::SetEvent(consumer_ready_.Get());
-
-    HRESULT hr = consumer_.Consume();
-    return hr;
+    return consumer_.Consume();
   }
 
   static DWORD WINAPI ConsumerThreadMainProc(void* arg) {
     return reinterpret_cast<EtwTraceConsumerRealtimeTest*>(arg)->
         ConsumerThread();
   }
 
   HRESULT StartConsumerThread() {
     consumer_ready_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
     EXPECT_TRUE(consumer_ready_ != NULL);
-    consumer_thread_.Set(::CreateThread(NULL, 0, ConsumerThreadMainProc,
-        this, 0, NULL));
-    if (NULL == consumer_thread_.Get())
+    consumer_thread_.Set(::CreateThread(NULL, 0, ConsumerThreadMainProc, this,
+                                        0, NULL));
+    if (consumer_thread_.Get() == NULL)
       return HRESULT_FROM_WIN32(::GetLastError());
 
-    HRESULT hr = S_OK;
     HANDLE events[] = { consumer_ready_, consumer_thread_ };
-    DWORD result = ::WaitForMultipleObjects(arraysize(events), events,
-                                            FALSE, INFINITE);
+    DWORD result =
+        ::WaitForMultipleObjects(arraysize(events), events, FALSE, INFINITE);
     switch (result) {
       case WAIT_OBJECT_0:
         // The event was set, the consumer_ is ready.
         return S_OK;
+
       case WAIT_OBJECT_0 + 1: {
           // The thread finished. This may race with the event, so check
           // explicitly for the event here, before concluding there's trouble.
-          if (WAIT_OBJECT_0 == ::WaitForSingleObject(consumer_ready_, 0))
+          if (::WaitForSingleObject(consumer_ready_, 0) == WAIT_OBJECT_0)
             return S_OK;
           DWORD exit_code = 0;
-          if (::GetExitCodeThread(consumer_thread_, &exit_code))
-            return exit_code;
-          else
-            return HRESULT_FROM_WIN32(::GetLastError());
-          break;
+          return ::GetExitCodeThread(consumer_thread_, &exit_code) ?
+              exit_code : HRESULT_FROM_WIN32(::GetLastError());
         }
+
       default:
         return E_UNEXPECTED;
-        break;
     }
-
-    return hr;
   }
 
   // Waits for consumer_ thread to exit, and returns its exit code.
   HRESULT JoinConsumerThread() {
-    if (WAIT_OBJECT_0 != ::WaitForSingleObject(consumer_thread_, INFINITE))
+    if (::WaitForSingleObject(consumer_thread_, INFINITE) != WAIT_OBJECT_0)
       return HRESULT_FROM_WIN32(::GetLastError());
 
     DWORD exit_code = 0;
-    if (::GetExitCodeThread(consumer_thread_, &exit_code))
-      return exit_code;
-
-    return HRESULT_FROM_WIN32(::GetLastError());
+    return ::GetExitCodeThread(consumer_thread_, &exit_code) ?
+        exit_code : HRESULT_FROM_WIN32(::GetLastError());
   }
 
   TestConsumer consumer_;
   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) {
+  if (controller.StartRealtimeSession(session_name_.c_str(), 100 * 1024) ==
+      E_ACCESSDENIED) {
     VLOG(1) << "You must be an administrator to run this test on Vista";
     return;
   }
 
   // Start the consumer_.
   ASSERT_HRESULT_SUCCEEDED(StartConsumerThread());
 
   // Wait around for the consumer_ thread a bit.
   ASSERT_EQ(WAIT_TIMEOUT, ::WaitForSingleObject(consumer_thread_, 50));
-
   ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 
   // The consumer_ returns success on session stop.
   ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread());
 }
 
 namespace {
 
 // {57E47923-A549-476f-86CA-503D57F59E62}
-DEFINE_GUID(kTestEventType,
-  0x57e47923, 0xa549, 0x476f, 0x86, 0xca, 0x50, 0x3d, 0x57, 0xf5, 0x9e, 0x62);
+DEFINE_GUID(
+    kTestEventType,
+    0x57e47923, 0xa549, 0x476f, 0x86, 0xca, 0x50, 0x3d, 0x57, 0xf5, 0x9e, 0x62);
 
 }  // namespace
 
 TEST_F(EtwTraceConsumerRealtimeTest, ConsumeEvent) {
   EtwTraceController controller;
-  HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(),
-                                               100 * 1024);
-  if (hr == E_ACCESSDENIED) {
+  if (controller.StartRealtimeSession(session_name_.c_str(), 100 * 1024) ==
+      E_ACCESSDENIED) {
     VLOG(1) << "You must be an administrator to run this test on Vista";
     return;
   }
 
-  ASSERT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_,
-      TRACE_LEVEL_VERBOSE, 0xFFFFFFFF));
+  ASSERT_HRESULT_SUCCEEDED(controller.EnableProvider(
+      test_provider_, TRACE_LEVEL_VERBOSE, 0xFFFFFFFF));
 
   EtwTraceProvider provider(test_provider_);
   ASSERT_EQ(ERROR_SUCCESS, provider.Register());
 
   // Start the consumer_.
   ASSERT_HRESULT_SUCCEEDED(StartConsumerThread());
-
   ASSERT_EQ(0, TestConsumer::events_.size());
 
   EtwMofEvent<1> event(kTestEventType, 1, TRACE_LEVEL_ERROR);
   EXPECT_EQ(ERROR_SUCCESS, provider.Log(&event.header));
-
   EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(TestConsumer::sank_event_,
                                                  INFINITE));
   ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL));
   ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread());
   ASSERT_NE(0u, TestConsumer::events_.size());
 }
 
 namespace {
 
 // We run events through a file session to assert that
@@ skipping 24 matching lines @@
   HRESULT LogEventToTempSession(PEVENT_TRACE_HEADER header) {
     EtwTraceController controller;
 
     // Set up a file session.
     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(test_provider_,
-        TRACE_LEVEL_VERBOSE, 0xFFFFFFFF));
+    EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(
+        test_provider_, TRACE_LEVEL_VERBOSE, 0xFFFFFFFF));
 
     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(test_provider_));
     EXPECT_HRESULT_SUCCEEDED(provider.Unregister());
     EXPECT_HRESULT_SUCCEEDED(controller.Flush(NULL));
     EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
@@ skipping 46 matching lines @@
   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_TRUE(trace != NULL);
   ASSERT_EQ(sizeof(kData), trace->MofLength);
   ASSERT_STREQ(kData, reinterpret_cast<const char*>(trace->MofData));
 }
 
 }  // namespace win
 }  // namespace base