Reuse the eula terms from the chrome resources...

chrome/browser/first_run.cc

 // Copyright (c) 2006-2008 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 <atlbase.h>
 #include <atlcom.h>
 #include <windows.h>
 #include <shlobj.h>
 
 #include <sstream>
@@ skipping 14 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/hang_monitor/hung_window_detector.h"
 #include "chrome/browser/importer/importer.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/profile_manager.h"
 #include "chrome/browser/views/first_run_view.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_service.h"
+#include "chrome/common/resource_bundle.h"
 #include "chrome/common/result_codes.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/views/accelerator_handler.h"
 #include "chrome/views/window.h"
 
 #include "google_update_idl.h"
 
+#include "grit/locale_settings.h"
+
+
 namespace {
 
 // The kSentinelFile file absence will tell us it is a first run.
 const wchar_t kSentinelFile[] = L"First Run";
 
 // Gives the full path to the sentinel file. The file might not exist.
 bool GetFirstRunSentinelFilePath(std::wstring* path) {
   std::wstring exe_path;
   if (!PathService::Get(base::DIR_EXE, &exe_path))
     return false;
@@ skipping 51 matching lines @@
       DWORD exit_code;
       ::GetExitCodeProcess(handle, &exit_code);
       ::CloseHandle(handle);
       if (exit_code == installer_util::RENAME_SUCCESSFUL)
         return true;
     }
   }
   return false;
 }
 
-bool LaunchSetupWithParam(const std::wstring& param, int* ret_code) {
+bool LaunchSetupWithParam(const std::wstring& param, const std::wstring& value,
+                          int* ret_code) {
   FilePath exe_path;
   if (!PathService::Get(base::DIR_MODULE, &exe_path))
     return false;
   exe_path = exe_path.Append(installer_util::kInstallerDir);
   exe_path = exe_path.Append(installer_util::kSetupExe);
   base::ProcessHandle ph;
   CommandLine cl(exe_path.ToWStringHack());
-  cl.AppendSwitch(param);
+  cl.AppendSwitchWithValue(param, value);
   if (!base::LaunchApp(cl, false, false, &ph))
     return false;
   DWORD wr = ::WaitForSingleObject(ph, INFINITE);
   if (wr != WAIT_OBJECT_0)
     return false;
   return (TRUE == ::GetExitCodeProcess(ph, reinterpret_cast<DWORD*>(ret_code)));
 }
 
+bool WriteEULAtoTempFile(FilePath* eula_path) {
+  std::string terms =
+      ResourceBundle::GetSharedInstance().GetDataResource(IDR_TERMS_HTML);
+  if (terms.empty())
+    return false;
+  FilePath temp_dir;
+  if (!file_util::GetTempDir(&temp_dir))
+    return false;
+  *eula_path = temp_dir.Append(L"chrome_eula_iframe.html");
+  return (file_util::WriteFile(*eula_path, terms.c_str(), terms.size()) > 0);
+}
+
 }  // namespace
 
 bool FirstRun::IsChromeFirstRun() {
   std::wstring first_run_sentinel;
   if (!GetFirstRunSentinelFilePath(&first_run_sentinel))
     return false;
   if (file_util::PathExists(first_run_sentinel))
     return false;
   return true;
 }
@@ skipping 64 matching lines @@
   if (preference_details)
     *preference_details = parse_result;
 
   if (parse_result & installer_util::MASTER_PROFILE_ERROR)
     return true;
 
   if (parse_result & installer_util::MASTER_PROFILE_REQUIRE_EULA) {
     // 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.
-    int retcode = 0;
-    if (!LaunchSetupWithParam(installer_util::switches::kShowEula, &retcode) ||
-        (retcode == installer_util::EULA_REJECTED)) {
-      LOG(WARNING) << "EULA rejected. Fast exit.";
-      ::ExitProcess(1);
-    }
-    if (retcode == installer_util::EULA_ACCEPTED) {
-      LOG(INFO) << "EULA : no collection";
-      GoogleUpdateSettings::SetCollectStatsConsent(false);
-    } else if (retcode == installer_util::EULA_ACCEPTED_OPT_IN) {
-      LOG(INFO) << "EULA : collection consent";
-      GoogleUpdateSettings::SetCollectStatsConsent(true);
+
+    // 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)) {

[Glenn Wilson, 2009/03/18 01:43:24]

If the EULA is empty (language not supported?) or the temp dir is not available,
shouldn't we exit?  Could I circumvent the EULA by just deleting my temp dir
environment variable or choosing an unsupported language?

[cpu_(ooo_6.6-7.5), 2009/03/18 05:33:20]

The temp dir is given by a window api which does not rely on the env var. But I
guess you might be able to mess with it somehow.

The fallback looks like is English, so looks like you should always get
something (even in chromium build you get something !!) unless for some reason
we fail to write the file.

We could to ::ExitProcess(1) as we do in line 247 if you like.

+      int retcode = 0;
+      const std::wstring& eula =  installer_util::switches::kShowEula;
+      if (!LaunchSetupWithParam(eula, inner_html.ToWStringHack(), &retcode) ||
+          (retcode == installer_util::EULA_REJECTED)) {
+        LOG(WARNING) << "EULA rejected. Fast exit.";
+        ::ExitProcess(1);
+      }
+      if (retcode == installer_util::EULA_ACCEPTED) {
+        LOG(INFO) << "EULA : no collection";
+        GoogleUpdateSettings::SetCollectStatsConsent(false);
+      } else if (retcode == installer_util::EULA_ACCEPTED_OPT_IN) {
+        LOG(INFO) << "EULA : collection consent";
+        GoogleUpdateSettings::SetCollectStatsConsent(true);
+      }
     }
   }
 
   FilePath user_prefs = FilePath::FromWStringHack(
       GetDefaultPrefFilePath(true, user_data_dir.ToWStringHack()));
   if (user_prefs.empty())
     return true;
 
   // The master prefs are regular prefs so we can just copy the file
   // to the default place and they just work.
@@ skipping 341 matching lines @@
 bool FirstRun::SetShowWelcomePagePref() {
   PrefService* local_state = g_browser_process->local_state();
   if (!local_state)
     return false;
   if (!local_state->IsPrefRegistered(prefs::kShouldShowWelcomePage)) {
     local_state->RegisterBooleanPref(prefs::kShouldShowWelcomePage, false);
     local_state->SetBoolean(prefs::kShouldShowWelcomePage, true);
   }
   return true;
 }