Set GTK_PATH to CHROMIUM_SAVED_GTK_PATH before launching xdg-open....

base/process_util_linux.cc

 // Copyright (c) 2008 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 "base/process_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <fcntl.h>
-#include <string>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
+#include <string>
+
 #include "base/eintr_wrapper.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 
 namespace {
 
 enum ParsingState {
   KEY_NAME,
@@ skipping 54 matching lines @@
   char exename[2048];
   ssize_t len = readlink(stat_file.value().c_str(), exename, sizeof(exename));
   if (len < 1) {
     // No such process.  Happens frequently in e.g. TerminateAllChromeProcesses
     return FilePath();
   }
   return FilePath(std::string(exename, len));
 }
 
 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) {
   pid_t pid = fork();
   if (pid < 0)
     return false;
 
   if (pid == 0) {
+    // Child process
     InjectiveMultimap fd_shuffle;
     for (file_handle_mapping_vector::const_iterator
         it = fds_to_remap.begin(); it != fds_to_remap.end(); ++it) {
       fd_shuffle.push_back(InjectionArc(it->first, it->second, false));
     }
 
+    for (environment_vector::const_iterator it = environ.begin();
+         it != environ.end(); ++it) {
+      if (it->first) {
+        if (it->second) {
+          setenv(it->first, it->second, 1);
+        } else {
+          unsetenv(it->first);
+        }
+      }
+    }
+
     if (!ShuffleFileDescriptors(fd_shuffle))
       exit(127);
 
     // If we are using the SUID sandbox, it sets a magic environment variable
     // ("SBX_D"), so we remove that variable from the environment here on the
     // off chance that it's already set.
     unsetenv("SBX_D");
 
     CloseSuperfluousFds(fd_shuffle);
 
     scoped_array<char*> argv_cstr(new char*[argv.size() + 1]);
     for (size_t i = 0; i < argv.size(); i++)
       argv_cstr[i] = const_cast<char*>(argv[i].c_str());
     argv_cstr[argv.size()] = NULL;
     execvp(argv_cstr[0], argv_cstr.get());
     LOG(ERROR) << "LaunchApp: exec failed!, argv_cstr[0] " << argv_cstr[0]
         << ", errno " << errno;
     exit(127);
   } else {
+    // Parent process
     if (wait)
       HANDLE_EINTR(waitpid(pid, 0, 0));
 
     if (process_handle)
       *process_handle = pid;
   }
 
   return true;
 }
 
+bool LaunchApp(const std::vector<std::string>& argv,
+               const file_handle_mapping_vector& fds_to_remap,
+               bool wait, ProcessHandle* process_handle) {
+  base::environment_vector no_env;
+  return LaunchApp(argv, no_env, fds_to_remap, wait, process_handle);
+}
+
 bool LaunchApp(const CommandLine& cl,
                bool wait, bool start_hidden,
                ProcessHandle* process_handle) {
   file_handle_mapping_vector no_files;
   return LaunchApp(cl.argv(), no_files, wait, process_handle);
 }
 
 NamedProcessIterator::NamedProcessIterator(const std::wstring& executable_name,
                                            const ProcessFilter* filter)
     : executable_name_(executable_name), filter_(filter) {
@@ skipping 185 matching lines @@
           (*io_counters).WriteTransferCount = StringToInt64(tokenizer.token());
         }
         state = KEY_NAME;
         break;
     }
   }
   return true;
 }
 
 }  // namespace base