TabManager: Set OOM scores via a new debugd interface on ChromeOS.

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 "chromeos/dbus/debug_daemon_client.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <unistd.h>
+
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 264 matching lines @@
   std::string GetTracingAgentName() override { return kCrOSTracingAgentName; }
 
   std::string GetTraceEventLabel() override { return kCrOSTraceLabel; }
 
   void StartAgentTracing(const base::trace_event::TraceConfig& trace_config,
                          const StartAgentTracingCallback& callback) override {
     dbus::MethodCall method_call(
         debugd::kDebugdInterface,
         debugd::kSystraceStart);
     dbus::MessageWriter writer(&method_call);
-    writer.AppendString("all"); // TODO(sleffler) parameterize category list
+    writer.AppendString("all");  // TODO(sleffler) parameterize category list
 
     DVLOG(1) << "Requesting a systrace start";
     debugdaemon_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&DebugDaemonClientImpl::OnStartMethod,
                    weak_ptr_factory_.GetWeakPtr()));
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
@@ skipping 129 matching lines @@
         base::Bind(&DebugDaemonClientImpl::OnRemoveRootfsVerification,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   void WaitForServiceToBeAvailable(
       const WaitForServiceToBeAvailableCallback& callback) override {
     debugdaemon_proxy_->WaitForServiceToBeAvailable(callback);
   }
 
+  void SetOomScoreAdj(const std::map<pid_t, int32_t>& pid_to_oom_score_adj,
+                      const SetOomScoreAdjCallback& callback) override {
+    dbus::MethodCall method_call(debugd::kDebugdInterface,
+                                 debugd::kSetOomScoreAdj);
+    dbus::MessageWriter writer(&method_call);
+
+    dbus::MessageWriter sub_writer(nullptr);
+    writer.OpenArray("{ii}", &sub_writer);
+
+    dbus::MessageWriter elem_writer(nullptr);
+    for (const auto& entry : pid_to_oom_score_adj) {
+      sub_writer.OpenDictEntry(&elem_writer);
+      elem_writer.AppendInt32(entry.first);
+      elem_writer.AppendInt32(entry.second);
+      sub_writer.CloseContainer(&elem_writer);
+    }
+    writer.CloseContainer(&sub_writer);
+
+    debugdaemon_proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&DebugDaemonClientImpl::OnSetOomScoreAdj,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
  protected:
   void Init(dbus::Bus* bus) override {
     debugdaemon_proxy_ =
         bus->GetObjectProxy(debugd::kDebugdServiceName,
                             dbus::ObjectPath(debugd::kDebugdServicePath));
   }
 
  private:
   // Called when a response for GetDebugLogs() is received.
   void OnGetDebugLogs(const GetDebugLogsCallback& callback,
@@ skipping 65 matching lines @@
     std::string status;
     if (response && dbus::MessageReader(response).PopString(&status))
       callback.Run(true, status);
     else
       callback.Run(false, "");
   }
 
   void OnGetAllLogs(const GetLogsCallback& callback,
                     dbus::Response* response) {
     std::map<std::string, std::string> logs;
-    bool broken = false; // did we see a broken (k,v) pair?
+    bool broken = false;  // did we see a broken (k,v) pair?
     dbus::MessageReader sub_reader(NULL);
     if (!response || !dbus::MessageReader(response).PopArray(&sub_reader)) {
       callback.Run(false, logs);
       return;
     }
     while (sub_reader.HasMoreData()) {
       dbus::MessageReader sub_sub_reader(NULL);
       std::string key, value;
       if (!sub_reader.PopDictEntry(&sub_sub_reader)
           || !sub_sub_reader.PopString(&key)
@@ skipping 75 matching lines @@
     callback.Run(response != NULL);
   }
 
   // Called when a response for StopAgentTracing() is received.
   void OnStopAgentTracing(dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Failed to request systrace stop";
       // If debugd crashes or completes I/O before this message is processed
       // then pipe_reader_ can be NULL, see OnIOComplete().
       if (pipe_reader_.get())
-        pipe_reader_->OnDataReady(-1); // terminate data stream
+        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() {
     std::string pipe_data;
     pipe_reader_->GetData(&pipe_data);
     callback_.Run(GetTracingAgentName(), GetTraceEventLabel(),
                   base::RefCountedString::TakeString(&pipe_data));
     pipe_reader_.reset();
   }
 
+  void OnSetOomScoreAdj(const SetOomScoreAdjCallback& callback,
+                        dbus::Response* response) {
+    std::string output;
+    if (response && dbus::MessageReader(response).PopString(&output))
+      callback.Run(true, output);
+    else
+      callback.Run(false, "");
+  }
+
   dbus::ObjectProxy* debugdaemon_proxy_;
   std::unique_ptr<PipeReaderForString> pipe_reader_;
   StopAgentTracingCallback callback_;
   scoped_refptr<base::TaskRunner> stop_agent_tracing_task_runner_;
   base::WeakPtrFactory<DebugDaemonClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DebugDaemonClientImpl);
 };
 
 DebugDaemonClient::DebugDaemonClient() {
 }
 
 DebugDaemonClient::~DebugDaemonClient() {
 }
 
 // static
 DebugDaemonClient::StopAgentTracingCallback
 DebugDaemonClient::EmptyStopAgentTracingCallback() {
   return base::Bind(&EmptyStopAgentTracingCallbackBody);
 }
 
 // static
 DebugDaemonClient* DebugDaemonClient::Create() {
   return new DebugDaemonClientImpl();
 }
 
 }  // namespace chromeos