Replace most LOG statements with DLOG statements in base.

base/synchronization/waitable_event_win.cc

 // Copyright (c) 2011 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/synchronization/waitable_event.h"
 
 #include <math.h>
 #include <windows.h>
 
 #include "base/logging.h"
@@ skipping 57 matching lines @@
   }
   // It is most unexpected that this should ever fail.  Help consumers learn
   // about it if it should ever fail.
   NOTREACHED() << "WaitForSingleObject failed";
   return false;
 }
 
 // static
 size_t WaitableEvent::WaitMany(WaitableEvent** events, size_t count) {
   HANDLE handles[MAXIMUM_WAIT_OBJECTS];
-  CHECK_LE(count, MAXIMUM_WAIT_OBJECTS)
+  DCHECK_LE(count, MAXIMUM_WAIT_OBJECTS)

[jar (doing other things), 2011/10/23 00:36:28]

This protects us from a buffer overrun if we could be fooled into having too
many waitable events :-/.  I also wouldn't be surprised is some dynamic set of
events led us to violating this restriction some day.  I think CHECK() might be
good.

If you want to yank the CHECK, you need something (at least) like:
count = std::min(count, MAXIMUM_WAIT_OBJECTS);

...but even then... it varies the semantics by not waiting for some of the
supplied items :-(.  Again, crashing might be better.

       << "Can only wait on " << MAXIMUM_WAIT_OBJECTS << " with WaitMany";
 
   for (size_t i = 0; i < count; ++i)
     handles[i] = events[i]->handle();
 
   // The cast is safe because count is small - see the CHECK above.
   DWORD result =
       WaitForMultipleObjects(static_cast<DWORD>(count),
                              handles,
                              FALSE,      // don't wait for all the objects
                              INFINITE);  // no timeout
   if (result >= WAIT_OBJECT_0 + count) {
     NOTREACHED() << "WaitForMultipleObjects failed: " << GetLastError();
     return 0;
   }
 
   return result - WAIT_OBJECT_0;
 }
 
 }  // namespace base