Replace most LOG statements with DLOG statements in base.

base/files/file_path_watcher_mac.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/files/file_path_watcher.h"
 
 #include <fcntl.h>
 #include <sys/event.h>
 #include <sys/param.h>
 
@@ skipping 177 matching lines @@
 int FilePathWatcherImpl::FileDescriptorForPath(const FilePath& path) {
   return HANDLE_EINTR(open(path.value().c_str(), O_EVTONLY));
 }
 
 void FilePathWatcherImpl::CloseFileDescriptor(int *fd) {
   if (*fd == -1) {
     return;
   }
 
   if (HANDLE_EINTR(close(*fd)) != 0) {
-    PLOG(ERROR) << "close";
+    DPLOG(ERROR) << "close";
   }
   *fd = -1;
 }
 
 bool FilePathWatcherImpl::AreKeventValuesValid(struct kevent* kevents,
                                                int count) {
   if (count < 0) {
-    PLOG(ERROR) << "kevent";
+    DPLOG(ERROR) << "kevent";
     return false;
   }
   bool valid = true;
   for (int i = 0; i < count; ++i) {
     if (kevents[i].flags & EV_ERROR && kevents[i].data) {
       // Find the kevent in |events_| that matches the kevent with the error.
       EventVector::iterator event = events_.begin();
       for (; event != events_.end(); ++event) {
         if (event->ident == kevents[i].ident) {
           break;
         }
       }
       std::string path_name;
       if (event != events_.end()) {
         EventData* event_data = EventDataForKevent(*event);
         if (event_data != NULL) {
           path_name = event_data->path_.value();
         }
       }
       if (path_name.empty()) {
         path_name = base::StringPrintf(
             "fd %d", *reinterpret_cast<int*>(&kevents[i].ident));
       }
-      LOG(ERROR) << "Error: " << kevents[i].data << " for " << path_name;
+      DLOG(ERROR) << "Error: " << kevents[i].data << " for " << path_name;
       valid = false;
     }
   }
   return valid;
 }
 
 void FilePathWatcherImpl::HandleAttributesChange(
     const EventVector::iterator& event,
     bool* target_file_affected,
     bool* update_watches) {
@@ skipping 90 matching lines @@
       } else {
         break;
       }
     }
   }
   return true;
 }
 
 void FilePathWatcherImpl::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK(MessageLoopForIO::current());
-  CHECK_EQ(fd, kqueue_);
-  CHECK(events_.size());
+  DCHECK_EQ(fd, kqueue_);
+  DCHECK(events_.size());
 
   // Request the file system update notifications that have occurred and return
   // them in |updates|. |count| will contain the number of updates that have
   // occurred.
   EventVector updates(events_.size());
   struct timespec timeout = {0, 0};
   int count = HANDLE_EINTR(kevent(kqueue_, NULL, 0, &updates[0], updates.size(),
                                   &timeout));
 
   // Error values are stored within updates, so check to make sure that no
@@ skipping 72 matching lines @@
   DCHECK_EQ(kqueue_, -1);
 
   delegate_ = delegate;
   target_ = path;
 
   MessageLoop::current()->AddDestructionObserver(this);
   io_message_loop_ = base::MessageLoopProxy::current();
 
   kqueue_ = kqueue();
   if (kqueue_ == -1) {
-    PLOG(ERROR) << "kqueue";
+    DPLOG(ERROR) << "kqueue";
     return false;
   }
 
   int last_entry = EventsForPath(target_, &events_);
-  CHECK_NE(last_entry, 0);
+  DCHECK_NE(last_entry, 0);
 
   EventVector responses(last_entry);
 
   int count = HANDLE_EINTR(kevent(kqueue_, &events_[0], last_entry,
                                   &responses[0], last_entry, NULL));
   if (!AreKeventValuesValid(&responses[0], count)) {
     // Calling Cancel() here to close any file descriptors that were opened.
     // This would happen in the destructor anyways, but FilePathWatchers tend to
     // be long lived, and if an error has occurred, there is no reason to waste
     // the file descriptors.
@@ skipping 34 matching lines @@
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace files
 }  // namespace base