base:Bind: Convert ipc/.

ipc/ipc_logging.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 "ipc/ipc_logging.h"
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
 #define IPC_MESSAGE_MACROS_LOG_ENABLED
 #endif
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/ipc_sync_message.h"
 #include "ipc/ipc_message_utils.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
 
 using base::Time;
 
-// IPC::Logging is allocated as a singleton, so we don't need any kind of
-// special retention program.
-DISABLE_RUNNABLE_METHOD_REFCOUNT(IPC::Logging);
-
 namespace IPC {
 
 const int kLogSendDelayMs = 100;
 
 // We use a pointer to the function table to avoid any linker dependencies on
 // all the traits used as IPC message parameters.
 LogFunctionMap* Logging::log_function_map_;
 
 Logging::Logging()
     : enabled_(false),
@@ skipping 110 matching lines @@
       !message.received_time() ||
       message.dont_log())
     return;
 
   LogData data;
   GenerateLogData(channel_id, message, &data, true);
 
   if (MessageLoop::current() == main_thread_) {
     Log(data);
   } else {
-    main_thread_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &Logging::Log, data));
+    main_thread_->PostTask(
+        FROM_HERE, base::Bind(&Logging::Log, base::Unretained(this), data));
   }
 }
 
 void Logging::GetMessageText(uint32 type, std::string* name,
                              const Message* message,
                              std::string* params) {
   if (!log_function_map_)
     return;
 
   LogFunctionMap::iterator it = log_function_map_->find(type);
@@ skipping 48 matching lines @@
 void Logging::Log(const LogData& data) {
   if (consumer_) {
     // We're in the browser process.
     consumer_->Log(data);
   } else {
     // We're in the renderer or plugin processes.
     if (sender_) {
       queued_logs_.push_back(data);
       if (!queue_invoke_later_pending_) {
         queue_invoke_later_pending_ = true;
-        MessageLoop::current()->PostDelayedTask(FROM_HERE, NewRunnableMethod(
-            this, &Logging::OnSendLogs), kLogSendDelayMs);
+        MessageLoop::current()->PostDelayedTask(
+            FROM_HERE, base::Bind(&Logging::OnSendLogs, base::Unretained(this)),
+            kLogSendDelayMs);
       }
     }
   }
   if (enabled_on_stderr_) {
     std::string message_name;
     if (data.message_name.empty()) {
       message_name = StringPrintf("[unknown type %d]", data.type);
     } else {
       message_name = data.message_name;
     }
@@ skipping 58 matching lines @@
     data->receive = message.received_time();
     data->dispatch = Time::Now().ToInternalValue();
     data->params = params;
     data->message_name = message_name;
   }
 }
 
 }
 
 #endif  // IPC_MESSAGE_LOG_ENABLED