Remove hard dependency on bundled python_26 in tests

net/test/spawned_test_server/local_test_server_win.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 "net/test/spawned_test_server/local_test_server.h"
 
 #include <windows.h>
 #include <wincrypt.h>
 
 #include "base/base_paths.h"
@@ skipping 67 matching lines @@
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
 namespace net {
 
+class AddedPythonPath {
+private:
+  bool path_modified_;
+  LPTSTR old_path_;
+
+public:
+  AddedPythonPath();
+  ~AddedPythonPath();
+};
+
+AddedPythonPath::AddedPythonPath() : path_modified_(false), old_path_(NULL) {

[Paweł Hajdan Jr., 2013/08/01 17:56:28]

Could you reuse ScopedEnvironmentVariable from e.g.
chrome/common/multi_process_lock_unittest.cc ? It can be moved to base or
base/test (if you can't get it to base, I can accept it into base/test as the
OWNER of it).

[Daniel Bratell, 2013/08/02 07:27:53]

I took a look at it and it has slightly different semantics since it will
unconditionally remove the variable after using it. It's also not very big so
there wouldn't be much code used from it. But I did take the hint from its use
of base::Environment which means that this class also shrank a lot. Thanks!

[Paweł Hajdan Jr., 2013/08/19 19:16:55]

Let's make the version you created for this purpose reusable and re-use it in
multi_process_lock_unittest.cc .

+  // Retrieves the old path, adds third_party/python26 to the end of it and
+  // then restores the original path in the destructor.
+
+  DWORD result = GetEnvironmentVariable(TEXT("PATH"), NULL, 0);
+  if (result == 0 && GetLastError() != ERROR_ENVVAR_NOT_FOUND)
+    return;
+
+  if (result != 0) {
+    old_path_ = new TCHAR[result];

[Paweł Hajdan Jr., 2013/08/01 17:56:28]

We generally avoid using TCHAR, TEXT, and LPTSTR directly unless really
necessary. With base::Environment this should get slightly better.

+    if (!old_path_)
+      return;
+
+    result = GetEnvironmentVariable(TEXT("PATH"), old_path_, result);
+    if (result == 0) {
+      // PATH Variable has disappeared or something went wrong in Windows.
+      // We just do nothing.
+      return;
+    }
+  }
+
+  base::FilePath dir;
+  if (!PathService::Get(base::DIR_SOURCE_ROOT, &dir))
+    return;
+  dir = dir.Append(FILE_PATH_LITERAL("third_party"))
+           .Append(FILE_PATH_LITERAL("python_26"));
+
+  base::string16 new_path = dir.AsUTF16Unsafe();
+
+  size_t new_value_len = new_path.length() + 1;
+  if (old_path_) {
+    new_value_len += 1 + wcslen(old_path_);
+  }
+
+  LPTSTR new_value = new TCHAR[new_value_len];
+  if (!new_value)
+      return;
+
+  if (old_path_) {
+    wcscpy(new_value, old_path_);
+    wcscat(new_value, TEXT(";")); // Add separator
+  }
+  else
+    new_value[0] = '\0';
+
+  // Add new path to the end so system pythons are used if available.
+  wcscat(new_value, new_path.c_str());
+  result = SetEnvironmentVariable(TEXT("PATH"), new_value);
+  delete[] new_value;
+  if (result == 0)
+      return;
+  path_modified_ = true;
+}
+
+AddedPythonPath::~AddedPythonPath() {
+  if (path_modified_) {
+    // old_path_ can be NULL in which case the variable will be
+    // removed. That is what we want.
+    (void)SetEnvironmentVariable(TEXT("PATH"), old_path_);
+  }
+
+  delete[] old_path_;
+}
+
 bool LocalTestServer::LaunchPython(const base::FilePath& testserver_path) {
   CommandLine python_command(CommandLine::NO_PROGRAM);
   if (!GetPythonCommand(&python_command))
     return false;
 
   python_command.AppendArgPath(testserver_path);
   if (!AddCommandLineArguments(&python_command))
     return false;
 
   HANDLE child_read = NULL;
@@ skipping 29 matching lines @@
   if (!job_handle_.IsValid()) {
     LOG(ERROR) << "Could not create JobObject.";
     return false;
   }
 
   if (!base::SetJobObjectAsKillOnJobClose(job_handle_.Get())) {
     LOG(ERROR) << "Could not SetInformationJobObject.";
     return false;
   }
 
+  AddedPythonPath python_path;
   base::LaunchOptions launch_options;
   launch_options.inherit_handles = true;
   launch_options.job_handle = job_handle_.Get();
   if (!base::LaunchProcess(python_command, launch_options, &process_handle_)) {
     LOG(ERROR) << "Failed to launch " << python_command.GetCommandLineString();
     return false;
   }
 
   return true;
 }
@@ skipping 19 matching lines @@
   if (!ParseServerData(server_data)) {
     LOG(ERROR) << "Could not parse server_data: " << server_data;
     return false;
   }
 
   return true;
 }
 
 }  // namespace net