debugd: Add TestICMP functionality.

chromeos/dbus/debug_daemon_client.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 <fcntl.h>
 #include <unistd.h>
 
 #include "chromeos/dbus/debug_daemon_client.h"
 
 #include "base/bind.h"
@@ skipping 288 matching lines @@
                    file_descriptor),
         base::Bind(&DebugDaemonClientImpl::OnCheckValidityRequestStopSystem,
                    weak_ptr_factory_.GetWeakPtr(),
                    base::Owned(file_descriptor),
                    callback),
         false);
 
     return true;
   }
 
+  virtual void TestICMP(const std::string& ip_address,
+                        const TestICMPCallback& callback) OVERRIDE {
+    dbus::MethodCall method_call(debugd::kDebugdInterface,
+                                 debugd::kTestICMP);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(ip_address);
+    debugdaemon_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&DebugDaemonClientImpl::OnTestICMP,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   callback));
+  }
+
  private:
   // Called to check descriptor validity on a thread where i/o is permitted.
   static void CheckValidity(dbus::FileDescriptor* file_descriptor) {
     file_descriptor->CheckValidity();
   }
 
   // Called when a CheckValidity response is received.
   void OnCheckValidityGetDebugLogs(dbus::FileDescriptor* file_descriptor,
                                    const GetDebugLogsCallback& callback) {
     // Issue the dbus request to get debug logs.
@@ skipping 132 matching lines @@
 
   // Called when a response for RequestStopSystemTracing() is received.
   void OnRequestStopSystemTracing(dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Failed to request systrace stop";
       pipe_reader_->OnDataReady(-1); // terminate data stream
     }
     // NB: requester is signaled when i/o completes
   }
 
+  void OnTestICMP(const TestICMPCallback& callback, dbus::Response* response) {
+    std::string status;
+    if (response && dbus::MessageReader(response).PopString(&status))
+      callback.Run(true, status);
+    else
+      callback.Run(false, "");
+  }
+
   // Called when pipe i/o completes; pass data on and delete the instance.
   void OnIOComplete() {
     callback_.Run(base::RefCountedString::TakeString(pipe_reader_->data()));
     pipe_reader_.reset();
   }
 
   dbus::ObjectProxy* debugdaemon_proxy_;
   base::WeakPtrFactory<DebugDaemonClientImpl> weak_ptr_factory_;
   scoped_ptr<PipeReader> pipe_reader_;
   StopSystemTracingCallback callback_;
@@ skipping 34 matching lines @@
     callback.Run(false, "");
   }
   virtual void GetNetworkInterfaces(
       const GetNetworkInterfacesCallback& callback) OVERRIDE {
     callback.Run(false, "");
   }
   virtual void GetAllLogs(const GetAllLogsCallback& callback) OVERRIDE {
     std::map<std::string, std::string> empty;
     callback.Run(false, empty);
   }
+
+  virtual void TestICMP(const std::string& ip_address,
+                        const TestICMPCallback& callback) OVERRIDE {
+    callback.Run(false, "");
+  }
 };
 
 DebugDaemonClient::DebugDaemonClient() {
 }
 
 DebugDaemonClient::~DebugDaemonClient() {
 }
 
 // static
 DebugDaemonClient::StopSystemTracingCallback
 DebugDaemonClient::EmptyStopSystemTracingCallback() {
   return base::Bind(&EmptyStopSystemTracingCallbackBody);
 }
 
 // static
 DebugDaemonClient* DebugDaemonClient::Create(DBusClientImplementationType type,
                                    dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new DebugDaemonClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new DebugDaemonClientStubImpl();
 }
 
 }  // namespace chromeos