linux: components support for base/

base/process_util.h

 // Copyright (c) 2011 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.
 
 // This file/namespace contains utility functions for enumerating, ending and
 // computing statistics of processes.
 
 #ifndef BASE_PROCESS_UTIL_H_
 #define BASE_PROCESS_UTIL_H_
 #pragma once
@@ skipping 152 matching lines @@
 // Win XP SP1 as well.
 BASE_API ProcessId GetProcId(ProcessHandle process);
 
 #if defined(OS_LINUX)
 // Returns the path to the executable of the given process.
 FilePath GetProcessExecutablePath(ProcessHandle process);
 
 // Parse the data found in /proc/<pid>/stat and return the sum of the
 // CPU-related ticks.  Returns -1 on parse error.
 // Exposed for testing.
-int ParseProcStatCPU(const std::string& input);
+BASE_API int ParseProcStatCPU(const std::string& input);
 
 static const char kAdjustOOMScoreSwitch[] = "--adjust-oom-score";
 
 // This adjusts /proc/process/oom_adj so the Linux OOM killer will prefer
 // certain process types over others. The range for the adjustment is
 // [-17,15], with [0,15] being user accessible.
 bool AdjustOOMScore(ProcessId process, int score);
 #endif
 
 #if defined(OS_POSIX)
 // Returns the ID for the parent of the given process.
-ProcessId GetParentProcessId(ProcessHandle process);
+BASE_API ProcessId GetParentProcessId(ProcessHandle process);
 
 // Close all file descriptors, except those which are a destination in the
 // given multimap. Only call this function in a child process where you know
 // that there aren't any other threads.
 void CloseSuperfluousFds(const InjectiveMultimap& saved_map);
 #endif
 
 #if defined(OS_WIN)
 
 enum IntegrityLevel {
@@ skipping 61 matching lines @@
 // Before launching all FDs open in the parent process will be marked as
 // close-on-exec.  |fds_to_remap| defines a mapping of src fd->dest fd to
 // propagate FDs into the child process.
 //
 // As above, if wait is true, execute synchronously. The pid will be stored
 // in process_handle if that pointer is non-null.
 //
 // Note that the first argument in argv must point to the executable filename.
 // If the filename is not fully specified, PATH will be searched.
 typedef std::vector<std::pair<int, int> > file_handle_mapping_vector;
-bool LaunchApp(const std::vector<std::string>& argv,
-               const file_handle_mapping_vector& fds_to_remap,
-               bool wait, ProcessHandle* process_handle);
+BASE_API bool LaunchApp(const std::vector<std::string>& argv,
+                        const file_handle_mapping_vector& fds_to_remap,
+                        bool wait, ProcessHandle* process_handle);
 
 // Similar to the above, but also (un)set environment variables in child process
 // through |environ|.
 typedef std::vector<std::pair<std::string, std::string> > environment_vector;
-bool LaunchApp(const std::vector<std::string>& argv,
-               const environment_vector& environ,
-               const file_handle_mapping_vector& fds_to_remap,
-               bool wait, ProcessHandle* process_handle);
+BASE_API bool LaunchApp(const std::vector<std::string>& argv,
+                        const environment_vector& environ,
+                        const file_handle_mapping_vector& fds_to_remap,
+                        bool wait, ProcessHandle* process_handle);
 
 // Similar to the above two methods, but starts the child process in a process
 // group of its own, instead of allowing it to inherit the parent's process
 // group. The pgid of the child process will be the same as its pid.
 bool LaunchAppInNewProcessGroup(const std::vector<std::string>& argv,
                                 const environment_vector& environ,
                                 const file_handle_mapping_vector& fds_to_remap,
                                 bool wait, ProcessHandle* process_handle);
 
 // AlterEnvironment returns a modified environment vector, constructed from the
 // given environment and the list of changes given in |changes|. Each key in
 // the environment is matched against the first element of the pairs. In the
 // event of a match, the value is replaced by the second of the pair, unless
 // the second is empty, in which case the key-value is removed.
 //
 // The returned array is allocated using new[] and must be freed by the caller.
-char** AlterEnvironment(const environment_vector& changes,
-                        const char* const* const env);
+BASE_API char** AlterEnvironment(const environment_vector& changes,
+                                 const char* const* const env);
 #endif  // defined(OS_POSIX)
 
 // Executes the application specified by cl. This function delegates to one
 // of the above two platform-specific functions.
 BASE_API bool LaunchApp(const CommandLine& cl, bool wait, bool start_hidden,
                         ProcessHandle* process_handle);
 
 // Executes the application specified by |cl| and wait for it to exit. Stores
 // the output (stdout) in |output|. Redirects stderr to /dev/null. Returns true
 // on success (application launched and exited cleanly, with exit code
 // indicating success).
 BASE_API bool GetAppOutput(const CommandLine& cl, std::string* output);
 
 #if defined(OS_POSIX)
 // A restricted version of |GetAppOutput()| which (a) clears the environment,
 // and (b) stores at most |max_output| bytes; also, it doesn't search the path
 // for the command.
-bool GetAppOutputRestricted(const CommandLine& cl,
-                            std::string* output, size_t max_output);
+BASE_API bool GetAppOutputRestricted(const CommandLine& cl,
+                                     std::string* output, size_t max_output);
 #endif
 
 // Used to filter processes by process ID.
 class ProcessFilter {
  public:
   // Returns true to indicate set-inclusion and false otherwise.  This method
   // should not have side-effects and should be idempotent.
   virtual bool Includes(const ProcessEntry& entry) const = 0;
 
  protected:
@@ skipping 318 matching lines @@
 // Note: Returns true on Windows 2000 without doing anything.
 BASE_API bool EnableLowFragmentationHeap();
 
 // Enables 'terminate on heap corruption' flag. Helps protect against heap
 // overflow. Has no effect if the OS doesn't provide the necessary facility.
 BASE_API void EnableTerminationOnHeapCorruption();
 
 #if !defined(OS_WIN)
 // Turns on process termination if memory runs out. This is handled on Windows
 // inside RegisterInvalidParamHandler().
-void EnableTerminationOnOutOfMemory();
+BASE_API void EnableTerminationOnOutOfMemory();
 #if defined(OS_MACOSX)
 // Exposed for testing.
 malloc_zone_t* GetPurgeableZone();
 #endif
 #endif
 
 // Enables stack dump to console output on exception and signals.
 // When enabled, the process will quit immediately. This is meant to be used in
 // unit_tests only!
 BASE_API bool EnableInProcessStackDumping();
 
 // If supported on the platform, and the user has sufficent rights, increase
 // the current process's scheduling priority to a high priority.
 BASE_API void RaiseProcessToHighPriority();
 
 #if defined(OS_MACOSX)
 // Restore the default exception handler, setting it to Apple Crash Reporter
 // (ReportCrash).  When forking and execing a new process, the child will
 // inherit the parent's exception ports, which may be set to the Breakpad
 // instance running inside the parent.  The parent's Breakpad instance should
 // not handle the child's exceptions.  Calling RestoreDefaultExceptionHandler
 // in the child after forking will restore the standard exception handler.
 // See http://crbug.com/20371/ for more details.
 void RestoreDefaultExceptionHandler();
 #endif  // defined(OS_MACOSX)
 
 }  // namespace base
 
 #endif  // BASE_PROCESS_UTIL_H_