Use InstallDetails in setup.

chrome/installer/setup/install_worker_unittest.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/installer/setup/install_worker.h"
 
+#include <memory>
+#include <utility>
 #include <vector>
 
+#include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "chrome/common/chrome_constants.h"
+#include "chrome/install_static/install_details.h"
+#include "chrome/install_static/install_modes.h"
 #include "chrome/installer/setup/setup_util.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/delete_reg_key_work_item.h"
 #include "chrome/installer/util/delete_tree_work_item.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/set_reg_value_work_item.h"
 #include "chrome/installer/util/util_constants.h"
@@ skipping 442 matching lines @@
                                            WorkItem::kWow64Default));
 
   std::unique_ptr<InstallationState> installation_state(
       BuildChromeInstallationState(system_level, multi_install));
 
   std::unique_ptr<InstallerState> installer_state(BuildChromeInstallerState(
       system_level, multi_install, *installation_state,
       InstallerState::SINGLE_INSTALL_OR_UPDATE));
 
   // Set up some expectations.
   // TODO(robertshield): Set up some real expectations.

[robertshield, 2016/11/04 12:50:35]

I don't know what this comment means anymore :-(

[grt (UTC plus 2), 2016/11/08 13:02:13]

Currently, this test is a bit bogus. It basically tests that a few functions are
called some number of times in any order. It doesn't really assert that
AddInstallWorkItems does anything in particular. I debated removing it
altogether since test_installer.py is our one hope for ensuring that the
installer does the right thing. I decided that doing that removal now was out of
scope for this CL. Do you have any thoughts about either leaving this test here,
removing it, or making it more of a "real" test?

[robertshield, 2016/11/08 22:03:40]

Not really, I agree that is basically an extremely weak version of
test_installer.py that really only tests "does something rather than checking
that anything specific happens. 

I'd be fairly happy to kill it, though agree that is out of scope for this cl.

   EXPECT_CALL(work_item_list, AddCopyTreeWorkItem(_, _, _, _, _))
       .Times(AtLeast(1));
   EXPECT_CALL(work_item_list, AddCreateRegKeyWorkItem(_, _, _))
       .WillRepeatedly(Return(create_reg_key_work_item.get()));
   EXPECT_CALL(work_item_list, AddSetRegStringValueWorkItem(_, _, _, _, _, _))
       .WillRepeatedly(Return(set_reg_value_work_item.get()));
   EXPECT_CALL(work_item_list, AddDeleteTreeWorkItem(_, _))
       .WillRepeatedly(Return(delete_tree_work_item.get()));
   EXPECT_CALL(work_item_list, AddDeleteRegKeyWorkItem(_, _, _))
       .WillRepeatedly(Return(delete_reg_key_work_item.get()));
 
+  // Install a basic InstallDetails instance and clean it up at the end.
+  std::unique_ptr<install_static::PrimaryInstallDetails> install_details(
+      base::MakeUnique<install_static::PrimaryInstallDetails>());
+  install_details->set_mode(&install_static::kInstallModes[0]);
+  install_static::InstallDetails::SetForProcess(std::move(install_details));
+  base::ScopedClosureRunner install_details_resetter(base::Bind(
+      []() { install_static::InstallDetails::SetForProcess(nullptr); }));
+
   AddInstallWorkItems(*installation_state.get(),
                       *installer_state.get(),
                       setup_path_,
                       archive_path_,
                       src_path_,
                       temp_dir_,
                       current_version_.get(),
                       *new_version_.get(),
                       &work_item_list);
 }
@@ skipping 324 matching lines @@
               prod_type_list[i_type_check]);
           bool prod_expect = (mach_after & (1 << i_type_check)) != 0;
           EXPECT_EQ(prod_expect, prod_res);
         }
       }
     }
   }
 }
 
 #endif  // defined(GOOGLE_CHROME_BUILD)