libchrome: Several upstreamable fixes from libchrome

dbus/bus.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.
 
 #include "dbus/bus.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 65 matching lines @@
     CHECK(success) << "Unable to allocate memory";
   }
 
   // Stops watching the underlying file descriptor.
   void StopWatching() {
     file_descriptor_watcher_.StopWatchingFileDescriptor();
   }
 
  private:
   // Implement MessagePumpLibevent::Watcher.
-  void OnFileCanReadWithoutBlocking(int file_descriptor) override {
+  void OnFileCanReadWithoutBlocking(int /*file_descriptor*/) override {
     const bool success = dbus_watch_handle(raw_watch_, DBUS_WATCH_READABLE);
     CHECK(success) << "Unable to allocate memory";
   }
 
   // Implement MessagePumpLibevent::Watcher.
-  void OnFileCanWriteWithoutBlocking(int file_descriptor) override {
+  void OnFileCanWriteWithoutBlocking(int /*file_descriptor*/) override {
     const bool success = dbus_watch_handle(raw_watch_, DBUS_WATCH_WRITABLE);
     CHECK(success) << "Unable to allocate memory";
   }
 
   DBusWatch* raw_watch_;
   base::MessagePumpLibevent::FileDescriptorWatcher file_descriptor_watcher_;
 };
 
 // The class is used for monitoring the timeout used for D-Bus method
 // calls.
@@ skipping 985 matching lines @@
 
   Timeout* timeout = static_cast<Timeout*>(dbus_timeout_get_data(raw_timeout));
   if (timeout->IsReadyToBeMonitored()) {
     timeout->StartMonitoring(this);
   } else {
     timeout->StopMonitoring();
   }
 }
 
 void Bus::OnDispatchStatusChanged(DBusConnection* connection,
-                                  DBusDispatchStatus status) {
+                                  DBusDispatchStatus /*status*/) {
   DCHECK_EQ(connection, connection_);
   AssertOnDBusThread();
 
   // We cannot call ProcessAllIncomingDataIfAny() here, as calling
   // dbus_connection_dispatch() inside DBusDispatchStatusFunction is
   // prohibited by the D-Bus library. Hence, we post a task here instead.
   // See comments for dbus_connection_set_dispatch_status_function().
   GetDBusTaskRunner()->PostTask(FROM_HERE,
                                 base::Bind(&Bus::ProcessAllIncomingDataIfAny,
                                            this));
@@ skipping 75 matching lines @@
 
 // static
 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
                                        DBusDispatchStatus status,
                                        void* data) {
   Bus* self = static_cast<Bus*>(data);
   self->OnDispatchStatusChanged(connection, status);
 }
 
 // static
-DBusHandlerResult Bus::OnConnectionDisconnectedFilter(
-    DBusConnection* connection,
-    DBusMessage* message,
-    void* data) {
+DBusHandlerResult Bus::OnConnectionDisconnectedFilter(DBusConnection*,
+                                                      DBusMessage* message,
+                                                      void* /*data*/) {
   if (dbus_message_is_signal(message,
                              DBUS_INTERFACE_LOCAL,
                              kDisconnectedSignal)) {
     // Abort when the connection is lost.
     LOG(FATAL) << "D-Bus connection was disconnected. Aborting.";
   }
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 // static
 DBusHandlerResult Bus::OnServiceOwnerChangedFilter(
-    DBusConnection* connection,
+    DBusConnection* /*connection*/,
     DBusMessage* message,
     void* data) {
   if (dbus_message_is_signal(message,
                              DBUS_INTERFACE_DBUS,
                              kNameOwnerChangedSignal)) {
     Bus* self = static_cast<Bus*>(data);
     self->OnServiceOwnerChanged(message);
   }
   // Always return unhandled to let others, e.g. ObjectProxies, handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus