[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 userDataDirPath;

[samuong, 2014/10/15 22:08:17]

For local variable names in C++, we use underscores rather than camelCase (see
http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Variable_Names).
Please try to stay as consistent as you can with existing code.

   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())
+    userDataDirPath = user_data_dir->path();
+  } else {
+    userDataDirPath = base::FilePath(switches.GetSwitchValue("user-data-dir"));
+  }
+  //

[samuong, 2014/10/15 22:08:17]

More style nitpicking: don't use empty comments like this, just use blank lines,
and stay consistent with existing code.

+  command.AppendArg("data:,");

[samuong, 2014/10/15 22:08:17]

Existing user data directories might have a home page set, and the test could
expect chrome to open this home page when it launches. So we should only add
"data:," to the command line if there is no user-data-dir specified.

+  Status status = internal::PrepareUserDataDir(
+                                  userDataDirPath  , capabilities.prefs.get(),
+                                  capabilities.local_state.get());
+  if (status.IsError())
       return status;
-  }
-
+  //
   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);
   if (status.IsError())
     return status;
   switches.AppendToCommandLine(&command);
   *prepared_command = command;
   return Status(kOk);
 }
@@ skipping 596 matching lines @@
   std::string prefs_str;
   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,

[samuong, 2014/10/15 22:08:17]

For function names in C++ like this, we use CamelCase and start the function
name with a capital letter (see
http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Function_Names).

+        const base::FilePath& path, base::DictionaryValue* mergePrefs) {
 
+    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);
+        }
+        mergePrefs->MergeDictionary(prefs);
+        // overwrite if any custom prefs
+        if (custom_prefs) {
+            for (base::DictionaryValue::Iterator it(*custom_prefs);
+                    !it.IsAtEnd(); it.Advance()) {
+                mergePrefs->Set(it.key(), it.value().DeepCopy());
+            }
+        }
+
+    } else { // nothing to  read - copy user define data directly
+        if (custom_prefs)
+            mergePrefs->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 =
+  //
+  base::DictionaryValue mergePrefs;
+  // merge to existed Preferences
+  Status status = mergeExistPrefFile(custom_prefs,
+          default_dir.Append(chrome::kPreferencesFilename),
+          &mergePrefs);
+  if (status.IsError())
+      return status;
+  // merge to template
+  status =
       WritePrefsFile(kPreferences,
-                     custom_prefs,
+                     &mergePrefs,
                      default_dir.Append(chrome::kPreferencesFilename));
   if (status.IsError())
-    return status;
+      return status;

[samuong, 2014/10/15 22:08:17]

C++ code should be indented with two spaces, not four (see
http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Spaces_vs._Tabs).
Please make sure you stay consistent with the existing coding style.

 
   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