Show about:sandbox status in the about:gpu page.

chrome/browser/ui/webui/gpu_internals_ui.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 "chrome/browser/ui/webui/gpu_internals_ui.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 16 matching lines @@
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "third_party/angle/src/common/version.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if defined(OS_LINUX) || defined(OS_OPENBSD)
+#include "content/public/browser/zygote_host_linux.h"
+#include "content/public/common/sandbox_linux.h"
+#endif
+
 using content::BrowserThread;
 using content::GpuDataManager;
 using content::WebContents;
 using content::WebUIMessageHandler;
 
 namespace {
 
 ChromeWebUIDataSource* CreateGpuHTMLSource() {
   ChromeWebUIDataSource* source =
       new ChromeWebUIDataSource(chrome::kChromeUIGpuInternalsHost);
@@ skipping 27 matching lines @@
 
   // CrashUploadList::Delegate implemenation.
   virtual void OnCrashListAvailable() OVERRIDE;
 
   // Messages
   void OnBrowserBridgeInitialized(const ListValue* list);
   void OnCallAsync(const ListValue* list);
 
   // Submessages dispatched from OnCallAsync
   Value* OnRequestClientInfo(const ListValue* list);
+  Value* OnRequestSandboxInfo(const ListValue* list);
   Value* OnRequestLogMessages(const ListValue* list);
   Value* OnRequestCrashList(const ListValue* list);
 
   // Executes the javascript function |function_name| in the renderer, passing
   // it the argument |value|.
   void CallJavascriptFunction(const std::wstring& function_name,
                               const Value* value);
 
  private:
   scoped_refptr<CrashUploadList> crash_list_;
@@ skipping 56 matching lines @@
     DCHECK(ok);
 
     Value* argCopy = arg->DeepCopy();
     submessageArgs->Append(argCopy);
   }
 
   // call the submessage handler
   Value* ret = NULL;
   if (submessage == "requestClientInfo") {
     ret = OnRequestClientInfo(submessageArgs);
+  } else if (submessage == "requestSandboxInfo") {
+    ret = OnRequestSandboxInfo(submessageArgs);
   } else if (submessage == "requestLogMessages") {
     ret = OnRequestLogMessages(submessageArgs);
   } else if (submessage == "requestCrashList") {
     ret = OnRequestCrashList(submessageArgs);
   } else {  // unrecognized submessage
     NOTREACHED();
     delete submessageArgs;
     return;
   }
   delete submessageArgs;
@@ skipping 60 matching lines @@
   dict->SetString("graphics_backend", "Skia");
 #else
   dict->SetString("graphics_backend", "Core Graphics");
 #endif
   dict->SetString("blacklist_version",
       GpuBlacklist::GetInstance()->GetVersion());
 
   return dict;
 }
 
+Value* GpuMessageHandler::OnRequestSandboxInfo(const ListValue*) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DictionaryValue* dict = new DictionaryValue();
+
+#if defined(OS_LINUX) || defined(OS_OPENBSD)
+  const int status = content::ZygoteHost::GetInstance()->GetSandboxStatus();
+  dict->SetBoolean("suid_sanbox", status & content::kSandboxLinuxSUID);
+  dict->SetBoolean("pid_namespaces", status & content::kSandboxLinuxPIDNS);
+  dict->SetBoolean("net_namespaces", status & content::kSandboxLinuxNetNS);
+  dict->SetBoolean("seccomp_legacy",
+      status & content::kSandboxLinuxSeccompLegacy);
+  dict->SetBoolean("seccomp_bpf", status & content::kSandboxLinuxSeccompBpf);
+  bool good = ((status & content::kSandboxLinuxSUID) &&
+               (status & content::kSandboxLinuxPIDNS)) ||
+              (status & content::kSandboxLinuxSeccompLegacy);
+  dict->SetBoolean("sandbox_ok", good);
+#else
+  dict->SetBoolean("suid_sanbox", false);
+  dict->SetBoolean("pid_namespaces", false);
+  dict->SetBoolean("net_namespaces", false);
+  dict->SetBoolean("seccomp_legacy", false);
+  dict->SetBoolean("seccomp_bpf", false);
+  dict->SetBoolean("sandbox_ok", true);
+#endif
+
+  return dict;
+}
+
 Value* GpuMessageHandler::OnRequestLogMessages(const ListValue*) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return GpuDataManager::GetInstance()->GetLogMessages().DeepCopy();
 }
 
 Value* GpuMessageHandler::OnRequestCrashList(const ListValue*) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!CrashesUI::CrashReportingEnabled()) {
@@ skipping 49 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 GpuInternalsUI::GpuInternalsUI(content::WebUI* web_ui)
     : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new GpuMessageHandler());
 
   // Set up the chrome://gpu-internals/ source.
   Profile* profile = Profile::FromWebUI(web_ui);
   ChromeURLDataManager::AddDataSource(profile, CreateGpuHTMLSource());
 }