Implementing app command to query EULA acceptance state for Chrome.

chrome/installer/util/eula_util.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/installer/util/eula_util.h"
+
+#include <windows.h>
+
+#include "base/file_util.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/installer/launcher_support/chrome_launcher_support.h"
+#include "chrome/installer/util/browser_distribution.h"
+#include "chrome/installer/util/install_util.h"
+#include "chrome/installer/util/installation_state.h"
+#include "chrome/installer/util/master_preferences.h"
+#include "chrome/installer/util/master_preferences_constants.h"
+#include "chrome/installer/util/util_constants.h"
+
+namespace installer {
+
+namespace {
+
+bool IsChromeFirstRun(BrowserDistribution* dist) {

[grt (UTC plus 2), 2013/01/24 02:51:40]

IsChromeFirstRun -> IsChromeFirstRunPending or something like that.

[huangs, 2013/01/24 18:56:03]

Done.

+  // If there is problem getting sentinel path, assume not first run.

[grt (UTC plus 2), 2013/01/24 02:51:40]

If there is a problem getting the sentinel path, assume Chrome has been run.

[huangs, 2013/01/24 18:56:03]

Done (rephrased to fit line).

+  FilePath first_run_sentinel;
+  return InstallUtil::GetSentinelFilePath(chrome::kFirstRunSentinel,
+                                          dist,
+                                          &first_run_sentinel)
+      && !file_util::PathExists(first_run_sentinel);
+}
+
+bool IsEULASentinelPresent(BrowserDistribution* dist ) {

[grt (UTC plus 2), 2013/01/24 02:51:40]

"dist " -> "dist"

[huangs, 2013/01/24 18:56:03]

Done.

+  // If there is problem getting sentinel path, assume EULA not accepted.
+  FilePath eula_sentinel;
+  return InstallUtil::GetSentinelFilePath(kEULASentinelFile,
+                                          dist,
+                                          &eula_sentinel)
+      && file_util::PathExists(eula_sentinel);
+}
+
+MasterPreferences* GetNewMasterPrefs() {

[grt (UTC plus 2), 2013/01/24 02:51:40]

scoped_ptr<MasterPreferences> GetNewMasterPrefs() {

[huangs, 2013/01/24 18:56:03]

Done.

+  // The standard location of the master prefs is next to the chrome binary.
+  FilePath chrome_exe(chrome_launcher_support::GetAnyChromePath());

[grt (UTC plus 2), 2013/01/24 02:51:40]

i haven't read what GetAnyChromePath does, but what you want here is
specifically the master_preferences file corresponding to the ProductState used
in IsEULAAccepted below. it should be in the directory
product_state.GetSetupPath().DirName().DirName().DirName().

[huangs, 2013/01/24 18:56:03]

Done (need to pass const ProductState& product_state).

+  if (!chrome_exe.empty()) {
+    FilePath master_prefs_path(chrome_exe.DirName());
+    MasterPreferences* install_prefs = new MasterPreferences(

[grt (UTC plus 2), 2013/01/24 02:51:40]

scoped_ptr<MasterPreferences> install_prefs(...);

[huangs, 2013/01/24 18:56:03]

Done.

+        master_prefs_path.AppendASCII(kDefaultMasterPrefs));
+    if (install_prefs != NULL) {

[grt (UTC plus 2), 2013/01/24 02:51:40]

    if (install_prefs && install_prefs->read_from_file())
      return install_prefs.Pass();
and remove line 52

[huangs, 2013/01/24 18:56:03]

Done.

+      if (install_prefs->read_from_file())
+        return install_prefs;
+
+      delete install_prefs;
+    }
+  }
+  return NULL;

[grt (UTC plus 2), 2013/01/24 02:51:40]

you may need to make this:
  return scoped_ptr<MasterPreferences>();

[huangs, 2013/01/24 18:56:03]

Done.  Thanks!

+}
+
+bool IsEULARequiredInMasterPrefs(MasterPreferences* install_prefs) {

[grt (UTC plus 2), 2013/01/24 02:51:40]

this function takes a MasterPreferences, so it doesn't need "MasterPrefs" in the
name. i suggest IsRequireEulaTrue since that accurately describes what the
function does. otherwise, i find this so trivial that putting it in its own
function obscures the code rather than clarifying it.

[huangs, 2013/01/24 18:56:03]

The function is added because I was envisioning replacing
  IsEULANotAccepted()
in first_run_win.cc by
  IsEULARequiredInMasterPrefs() && !IsEULASentinelPresent().
in the future.  But we're not touching that code, so this is redundant.  Removed
and inlined.

+  bool val = false;
+  // If kRequireEula value is absent, assume EULA is not required.
+  if (!install_prefs->GetBool(master_preferences::kRequireEula, &val))
+    return false;
+
+  return val;
+}
+
+}  // namespace
+
+HRESULT IsEULAAccepted() {
+  BrowserDistribution* dist = BrowserDistribution::GetSpecificDistribution(
+      BrowserDistribution::CHROME_BINARIES);
+  if (!dist)
+    return E_FAIL;  // Error: system-level binaries aren't installed.

[grt (UTC plus 2), 2013/01/24 02:51:40]

!dist means that the impossible happened rather than that the binaries aren't
installed. you don't need to check this.

[huangs, 2013/01/24 18:56:03]

Done.

+
+  ProductState binaries;
+  if (!binaries.Initialize(true, dist) && !binaries.Initialize(false, dist))

[grt (UTC plus 2), 2013/01/24 02:51:40]

eula only applies to system-level installs. you should not check for user-level.
for this to be comprehensive, you should fallback to checking for CHROME_BROWSER
if the binaries aren't installed and put a:
  LOG_IF(DFATAL, whatever.is_multi_install())
      << "binaries are not installed yet Chrome thinks it's multi-install.";

[huangs, 2013/01/24 18:56:03]

Done.  Also added logic to return EULA_YES when queries were made at user-level.

+    return E_FAIL;
+
+  // Is Omaha waiting for Chrome's EULA to be accepted?
+  DWORD eula_accepted = 0;
+  if (binaries.GetEulaAccepted(&eula_accepted) && !eula_accepted)
+    return 0;
+
+  // Has the current user been through first-run?
+  if (!IsChromeFirstRun(dist))

[grt (UTC plus 2), 2013/01/24 02:51:40]

use the BrowserDistribution::CHROME_BROWSER instance here.

[huangs, 2013/01/24 18:56:03]

Done.

+    return 1;
+

[grt (UTC plus 2), 2013/01/24 02:51:40]

is the result the same if the EULA sentinel check is moved here:
  if (IsEULASentinelPresent(dist))
    return 1;
if so, i think this is the teensiest bit more efficient since loading
master_prefs can be short-circuited in that case.

[huangs, 2013/01/24 18:56:03]

It's a bit bizarre since we check for "yes" before deciding if the check is even
necessary.  Making the change anyway, since this is short enough.

[grt (UTC plus 2), 2013/01/24 21:04:55]

it's an optimization. the cost of parsing master_preferences is significantly
higher than the cost of checking for the sentinel. as long as the logic is
correct, i think it makes sense.

+  scoped_ptr<MasterPreferences> install_prefs(GetNewMasterPrefs());
+  if (!install_prefs.get())

[grt (UTC plus 2), 2013/01/24 02:51:40]

if (!install_prefs)

[huangs, 2013/01/24 18:56:03]

Done.

+    return 0;
+
+  if (!IsEULARequiredInMasterPrefs(install_prefs.get()))
+    return 1;
+
+  return IsEULASentinelPresent(dist) ? 1 : 0;
+}
+
+}  // namespace installer