Implementing app command to query EULA acceptance state for Chrome.

chrome/browser/first_run/first_run_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 "chrome/browser/first_run/first_run.h"
 
 #include <shellapi.h>
 #include <shlobj.h>
 #include <windows.h>
 
 #include "base/callback.h"
 #include "base/environment.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/metro.h"
 #include "base/win/object_watcher.h"
+#include "base/win/registry.h"

[grt (UTC plus 2), 2013/01/23 19:02:29]

remove this

[huangs, 2013/01/24 00:08:08]

Moot; all Browser-specific changes are now gone.

 #include "base/win/windows_version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/first_run/first_run_import_observer.h"
 #include "chrome/browser/first_run/first_run_internal.h"
 #include "chrome/browser/importer/importer_host.h"
 #include "chrome/browser/importer/importer_list.h"
 #include "chrome/browser/importer/importer_progress_dialog.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/process_singleton.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/worker_thread_ticker.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/install_util.h"

[grt (UTC plus 2), 2013/01/23 19:02:29]

#include "chrome/installer/util/installation_state.h"

[huangs, 2013/01/24 00:08:08]

Done for eula_util.cc

 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "google_update/google_update_idl.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/win/shell.h"
 
 namespace {
 
+// Taken from google_update_constants.cc.

[grt (UTC plus 2), 2013/01/23 19:02:29]

remove these

[huangs, 2013/01/24 00:08:08]

Done.

+const wchar_t kRegPathGoogleUpdate[] = L"Software\\Google\\Update";
+const wchar_t kRegEULAAceptedField[] = L"eulaaccepted";
+
 // Launches the setup exe with the given parameter/value on the command-line.
 // For non-metro Windows, it waits for its termination, returns its exit code
 // in |*ret_code|, and returns true if the exit code is valid.
 // For metro Windows, it launches setup via ShellExecuteEx and returns in order
 // to bounce the user back to the desktop, then returns immediately.
 bool LaunchSetupForEula(const FilePath::StringType& value, int* ret_code) {
   FilePath exe_dir;
   if (!PathService::Get(base::DIR_MODULE, &exe_dir))
     return false;
   exe_dir = exe_dir.Append(installer::kInstallerDir);
@@ skipping 49 matching lines @@
   else if (!PathService::Get(chrome::DIR_USER_DATA, path))
     return false;
   *path = path->Append(file);
   return true;
 }
 
 bool GetEULASentinelFilePath(FilePath* path) {
   return GetSentinelFilePath(installer::kEULASentinelFile, path);
 }
 
-// Returns true if the EULA is required but has not been accepted by this user.
+// Reads HKLM/.../Google/Update/eulaaccepted into |value|.
+// Returns true and updates |value| if successful; else |value| is unchanged.
+bool GetGoogleUpdateEULAAccepted(DWORD* value) {

[grt (UTC plus 2), 2013/01/23 19:02:29]

remove this

[huangs, 2013/01/24 00:08:08]

Done.

+  base::win::RegKey key(HKEY_LOCAL_MACHINE, kRegPathGoogleUpdate,
+                        KEY_QUERY_VALUE);
+  return key.ReadValueDW(kRegEULAAceptedField, value) == ERROR_SUCCESS;
+}
+
+// Returns true if the EULA is not required, or has been accepted by this user.
 // The EULA is considered having been accepted if the user has gotten past
 // first run in the "other" environment (desktop or metro).
-bool IsEULANotAccepted(installer::MasterPreferences* install_prefs) {
-  bool value = false;
-  if (install_prefs->GetBool(installer::master_preferences::kRequireEula,
-          &value) && value) {
-    FilePath eula_sentinel;
-    // Be conservative and show the EULA if the path to the sentinel can't be
-    // determined.
-    if (!GetEULASentinelFilePath(&eula_sentinel) ||
-        !file_util::PathExists(eula_sentinel)) {
-      return true;
-    }
+bool IsEULAUnrequiredOrAccepted(installer::MasterPreferences* install_prefs) {

[grt (UTC plus 2), 2013/01/23 19:02:29]

please either justify this change or revert it and call !IsEULANotAccepted in
your new code.

[huangs, 2013/01/24 00:08:08]

Reverted in this file.  In eula_util.cc, decided to break this into two
routines:
IsEULARequiredInMasterPrefs() [return 1 if false],
IsEULASentinelPresent()  [return 1 iff true].

+  bool val = false;
+  // EULA not required if kRequireEula value is absent or false.
+  if (!install_prefs->GetBool(installer::master_preferences::kRequireEula, &val)
+      || !val) {
+    return true;
   }
-  return false;
+
+  // Be conservative: problem getting sentinel path means EULA is not accepted.
+  FilePath eula_sentinel;
+  return GetEULASentinelFilePath(&eula_sentinel)
+      && file_util::PathExists(eula_sentinel);
 }
 
 // Writes the EULA to a temporary file, returned in |*eula_path|, and returns
 // true if successful.
 bool WriteEULAtoTempFile(FilePath* eula_path) {
   std::string terms = l10n_util::GetStringUTF8(IDS_TERMS_HTML);
   if (terms.empty())
     return false;
   FILE *file = file_util::CreateAndOpenTemporaryFile(eula_path);
   if (!file)
@@ skipping 289 matching lines @@
     if (!ImportSettingsWin(NULL,
           importer_list->GetSourceProfileAt(0).importer_type,
           out_prefs->do_import_items,
           FilePath::FromWStringHack(UTF8ToWide(import_bookmarks_path)), true)) {
       LOG(WARNING) << "silent import failed";
     }
   }
 }
 
 bool ShowPostInstallEULAIfNeeded(installer::MasterPreferences* install_prefs) {
-  if (IsEULANotAccepted(install_prefs)) {
+  if (!IsEULAUnrequiredOrAccepted(install_prefs)) {
     // Show the post-installation EULA. This is done by setup.exe and the
     // result determines if we continue or not. We wait here until the user
     // dismisses the dialog.
 
     // The actual eula text is in a resource in chrome. We extract it to
     // a text file so setup.exe can use it as an inner frame.
     FilePath inner_html;
     if (WriteEULAtoTempFile(&inner_html)) {
       int retcode = 0;
       if (!LaunchSetupForEula(inner_html.value(), &retcode) ||
@@ skipping 32 matching lines @@
 }
 
 FilePath MasterPrefsPath() {
   // The standard location of the master prefs is next to the chrome binary.
   FilePath master_prefs;
   if (!PathService::Get(base::DIR_EXE, &master_prefs))
     return FilePath();
   return master_prefs.AppendASCII(installer::kDefaultMasterPrefs);
 }
 
+bool IsEULAAccepted() {
+  DWORD google_udpate_eula_accepted = 0;
+  if (GetGoogleUpdateEULAAccepted(&google_udpate_eula_accepted)

[grt (UTC plus 2), 2013/01/23 19:02:29]

why are you checking if google update's EULA has been accepted rather than
chrome's? i think you should instead do something like:

  installer::ProductState binaries;
  if (!binaries.Initialize(true, BrowserDistribution::CHROME_BINARIES)) {
    // Error: system-level binaries aren't installed. I'm not sure what you want
to do here.
  }

  // Is Omaha waiting for Chrome's EULA to be accepted?
  DWORD eula_accepted = 0;
  if (binaries.GetEulaAccepted(&eula_accepted) && !eula_accepted)
    return false;

  // Has the current user been through first-run?
  if (!IsChromeFirstRun())
    return true;

  // Will Chrome show the EULA on first-run?
  ...
  return !IsEULANotAccepted(install_prefs.get());

[huangs, 2013/01/24 00:08:08]

Made the change.  Also:
- Return value is HRESULT, with 0 if EULA not accepted, 1 if EULA accepted, and
E_FAIL on error.
- binaries.Initialize(): Checking for system level, THEN user level.

+      && !google_udpate_eula_accepted) {
+    return false;
+  }
+
+  if (!IsChromeFirstRun())
+    return true;
+
+  FilePath master_prefs_path;
+  scoped_ptr<installer::MasterPreferences>
+      install_prefs(internal::LoadMasterPrefs(&master_prefs_path));
+  if (!install_prefs.get())
+    return false;
+
+  return IsEULAUnrequiredOrAccepted(install_prefs.get());
+}
+
 }  // namespace first_run