Linux: make current InitializeSandbox() private.

content/common/sandbox_linux.h

 // 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.
 
 #ifndef CONTENT_COMMON_SANDBOX_LINUX_H_
 #define CONTENT_COMMON_SANDBOX_LINUX_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 15 matching lines @@
   // Skia.
   enum LinuxSandboxIPCMethods {
     METHOD_GET_FONT_FAMILY_FOR_CHARS = 32,
     METHOD_LOCALTIME = 33,
     METHOD_GET_CHILD_WITH_INODE = 34,
     METHOD_GET_STYLE_FOR_STRIKE = 35,
     METHOD_MAKE_SHARED_MEMORY_SEGMENT = 36,
     METHOD_MATCH_WITH_FALLBACK = 37,
   };
 
+  // A list of sandbox configuration for content's process types.
+  enum SandboxConfig {
+    SANDBOX_CONFIG_INVALID = 0,
+    SANDBOX_CONFIG_GENERIC,  // Exact sandbox unspecified, useful for pre-init.
+    SANDBOX_CONFIG_RENDERER,
+    SANDBOX_CONFIG_WORKER,
+    SANDBOX_CONFIG_GPU,
+    SANDBOX_CONFIG_PPAPI,
+    SANDBOX_CONFIG_UTILITY,
+  };
+
   // Get our singleton instance.
   static LinuxSandbox* GetInstance();
 
   // Do some initialization that can only be done before any of the sandboxes
   // is enabled.
   //
   // There are two versions of this function. One takes a process_type
   // as an argument, the other doesn't.
   // It may be necessary to call PreinitializeSandboxBegin before knowing the
   // process type (this is for instance the case with the Zygote).
   // In that case, it is crucial that PreinitializeSandboxFinish() gets
   // called for every child process.
   // TODO(markus, jln) we know this is not always done at the moment
   // (crbug.com/139877).
-  void PreinitializeSandbox(const std::string& process_type);
+  // These functions can accept SANDBOX_CONFIG_GENERIC as a parameter if the
+  // full type of the sandbox isn't known yet.
+  void PreinitializeSandbox(LinuxSandbox::SandboxConfig sandbox_config);
   // These should be called together.
   void PreinitializeSandboxBegin();
-  void PreinitializeSandboxFinish(const std::string& process_type);
+  void PreinitializeSandboxFinish(LinuxSandbox::SandboxConfig sandbox_config);
 
-  // Returns the Status of the sandbox. Can only be queried if we went through
-  // PreinitializeSandbox() or PreinitializeSandboxBegin(). This is a bitmask
-  // and uses the constants defined in "enum LinuxSandboxStatus".
+  // Initialize the sandbox with the given pre-built configuration. Currently
+  // seccomp-legacy, seccomp-bpf, address space limitations (the setuid sandbox
+  // works differently and is set-up in the Zygote). This will instanciate the

[Markus (顧孟勤), 2013/04/10 23:39:50]

s/instanciate/instantiate/

+  // LinuxSandbox singleton if it doesn't already exist.
+  static bool InitializeSandbox(LinuxSandbox::SandboxConfig sandbox_config);
+
+  // Returns the Status of the renderers' sandbox. Can only be queried if we
+  // went through PreinitializeSandbox() or PreinitializeSandboxBegin(). This
+  // is a bitmask and uses the constants defined in "enum LinuxSandboxStatus".
   // Since we need to provide the status before the sandboxes are actually
   // started, this returns what will actually happen once the various Start*
   // functions are called from inside a renderer.
   int GetStatus() const;
   // Is the current process single threaded?
   bool IsSingleThreaded() const;
   // Did we start Seccomp BPF?
   bool seccomp_bpf_started() const;
 
   // Simple accessor for our instance of the setuid sandbox. Will never return
   // NULL.
   // There is no StartSetuidSandbox(), the SetuidSandboxClient instance should
   // be used directly.
   sandbox::SetuidSandboxClient* setuid_sandbox_client() const;
 
   // Check the policy and eventually start the seccomp-legacy sandbox.
-  bool StartSeccompLegacy(const std::string& process_type);
+  bool StartSeccompLegacy(LinuxSandbox::SandboxConfig sandbox_config);
   // Check the policy and eventually start the seccomp-bpf sandbox. This should
   // never be called with threads started. If we detect that thread have
   // started we will crash.
-  bool StartSeccompBpf(const std::string& process_type);
+  bool StartSeccompBpf(LinuxSandbox::SandboxConfig sandbox_config);
 
   // Limit the address space of the current process (and its children).
   // to make some vulnerabilities harder to exploit.
-  bool LimitAddressSpace(const std::string& process_type);
+  bool LimitAddressSpace(LinuxSandbox::SandboxConfig sandbox_config);
 
  private:
   friend struct DefaultSingletonTraits<LinuxSandbox>;
 
   // We must have been pre_initialized_ before using either of these.
   bool seccomp_legacy_supported() const;
   bool seccomp_bpf_supported() const;
 
   int proc_fd_;
   bool seccomp_bpf_started_;
   // Have we been through PreinitializeSandbox or PreinitializeSandboxBegin?
   bool pre_initialized_;
   bool seccomp_legacy_supported_;  // Accurate if pre_initialized_.
   bool seccomp_bpf_supported_;  // Accurate if pre_initialized_.
   scoped_ptr<sandbox::SetuidSandboxClient> setuid_sandbox_client_;
 
   ~LinuxSandbox();
   DISALLOW_IMPLICIT_CONSTRUCTORS(LinuxSandbox);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_SANDBOX_LINUX_H_