[chromedriver] setting browser default download directory

chrome/test/chromedriver/chrome_launcher.cc

 // Copyright (c) 2013 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/test/chromedriver/chrome_launcher.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 110 matching lines @@
   switches.SetSwitch("remote-debugging-port", base::IntToString(port));
   switches.SetSwitch("test-type", "webdriver");
 
   for (std::set<std::string>::const_iterator iter =
            capabilities.exclude_switches.begin();
        iter != capabilities.exclude_switches.end();
        ++iter) {
     switches.RemoveSwitch(*iter);
   }
   switches.SetFromSwitches(capabilities.switches);
-
+  base::FilePath user_data_dir_path;
   if (!switches.HasSwitch("user-data-dir")) {
     command.AppendArg("data:,");
     if (!user_data_dir->CreateUniqueTempDir())
       return Status(kUnknownError, "cannot create temp dir for user data dir");
     switches.SetSwitch("user-data-dir", user_data_dir->path().value());
-    Status status = internal::PrepareUserDataDir(
-        user_data_dir->path(), capabilities.prefs.get(),
-        capabilities.local_state.get());
-    if (status.IsError())
+    user_data_dir_path = user_data_dir->path();
+  } else {
+    user_data_dir_path = base::FilePath(
+        switches.GetSwitchValue("user-data-dir"));
+  }
+
+  Status status = internal::PrepareUserDataDir(
+                         user_data_dir_path  , capabilities.prefs.get(),

[samuong, 2014/10/16 20:23:40]

I've just noticed that if you unconditionally call PrepareUserDataDir, it will
overwrite files such as "Local State" (see line 827). We don't want to do this,
and I think the best way to handle this is to move this back to where it was,
and do the merge only if there is a prefs object in the capabilities dictionary.

+                         capabilities.local_state.get());
+  if (status.IsError())
       return status;

[samuong, 2014/10/16 20:23:40]

This is indented too far in.

-  }
 
   if (!extension_dir->CreateUniqueTempDir()) {
     return Status(kUnknownError,
                   "cannot create temp dir for unpacking extensions");
   }
-  Status status = internal::ProcessExtensions(capabilities.extensions,
+  status = internal::ProcessExtensions(capabilities.extensions,
                                               extension_dir->path(),
                                               true,
                                               &switches,
                                               extension_bg_pages);

[samuong, 2014/10/16 20:23:40]

Reindent lines 154-157 so that they line up with the opening parenthesis on line
153.

In general, when breaking a function call over multiple lines, you can either
indent four spaces, or indent up to the opening parenthesis:

http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Function_Calls

This applies to both C++ as well as Python, and please fix this in other
occurrences in this file as well as the other files in your CL.

   if (status.IsError())
     return status;
   switches.AppendToCommandLine(&command);
   *prepared_command = command;
   return Status(kOk);
 }
 
 Status WaitForDevToolsAndCheckVersion(
     const NetAddress& address,
     URLRequestContextGetter* context_getter,
@@ skipping 593 matching lines @@
   base::JSONWriter::Write(prefs, &prefs_str);
   VLOG(0) << "Populating " << path.BaseName().value()
           << " file: " << PrettyPrintValue(*prefs);
   if (static_cast<int>(prefs_str.length()) != base::WriteFile(
           path, prefs_str.c_str(), prefs_str.length())) {
     return Status(kUnknownError, "failed to write prefs file");
   }
   return Status(kOk);
 }
 
+Status MergeExistPrefFile(const base::DictionaryValue* custom_prefs,
+    const base::FilePath& path, base::DictionaryValue* merge_prefs) {
+
+  if (base::PathExists(path)) { // if exist, import it
+    std::string data_read;
+    base::ReadFileToString(path, &data_read);
+    //
+    int code;
+    std::string error_msg;
+    scoped_ptr<base::Value> template_value(
+        base::JSONReader::ReadAndReturnError(data_read, 0, &code, &error_msg));
+
+    base::DictionaryValue* prefs = NULL;
+    if (!template_value || !template_value->GetAsDictionary(&prefs)) {
+      return Status(kUnknownError,
+          "cannot parse default Preference: " + error_msg);
+    }
+    merge_prefs->MergeDictionary(prefs);
+    // overwrite if any custom prefs
+    if (custom_prefs) {
+      for (base::DictionaryValue::Iterator it(*custom_prefs); !it.IsAtEnd();
+          it.Advance()) {
+        merge_prefs->Set(it.key(), it.value().DeepCopy());
+      }
+    }
+
+  } else { // nothing to  read - copy user define data directly
+    if (custom_prefs)
+      merge_prefs->MergeDictionary(custom_prefs);
+  }
+  return Status(kOk);
+}
+
 Status PrepareUserDataDir(
     const base::FilePath& user_data_dir,
     const base::DictionaryValue* custom_prefs,
     const base::DictionaryValue* custom_local_state) {
   base::FilePath default_dir =
       user_data_dir.AppendASCII(chrome::kInitialProfile);
   if (!base::CreateDirectory(default_dir))
     return Status(kUnknownError, "cannot create default profile directory");
 
-  Status status =
-      WritePrefsFile(kPreferences,
-                     custom_prefs,
-                     default_dir.Append(chrome::kPreferencesFilename));
+  base::DictionaryValue merge_prefs;
+  // merge to existed Preferences
+  Status status = MergeExistPrefFile(custom_prefs,
+      default_dir.Append(chrome::kPreferencesFilename),
+      &merge_prefs);
+  if (status.IsError())
+    return status;
+  // merge to template
+  status = WritePrefsFile(kPreferences,
+                          &merge_prefs,
+                          default_dir.Append(chrome::kPreferencesFilename));
   if (status.IsError())
     return status;
 
   status = WritePrefsFile(kLocalState,
                           custom_local_state,
                           user_data_dir.Append(chrome::kLocalStateFilename));
   if (status.IsError())
     return status;
 
   // Write empty "First Run" file, otherwise Chrome will wipe the default
   // profile that was written.
   if (base::WriteFile(
           user_data_dir.Append(chrome::kFirstRunSentinel), "", 0) != 0) {
     return Status(kUnknownError, "failed to write first run file");
   }
   return Status(kOk);
 }
 
 }  // namespace internal