Simplify ExtensionInstallChecker into a single-use class

chrome/browser/extensions/crx_installer.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_CRX_INSTALLER_H_
 #define CHROME_BROWSER_EXTENSIONS_CRX_INSTALLER_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/version.h"
 #include "chrome/browser/extensions/extension_install_checker.h"
@@ skipping 175 matching lines @@
 
   void set_install_immediately(bool val) {
     set_install_flag(kInstallFlagInstallImmediately, val);
   }
   void set_do_not_sync(bool val) {
     set_install_flag(kInstallFlagDoNotSync, val);
   }
 
   bool did_handle_successfully() const { return did_handle_successfully_; }
 
-  Profile* profile() { return install_checker_.profile(); }
+  Profile* profile() { return profile_; }
 
-  const Extension* extension() { return install_checker_.extension().get(); }
+  const Extension* extension() { return extension_.get(); }
 
   // The currently installed version of the extension, for updates. Will be
   // invalid if this isn't an update.
   const base::Version& current_version() const { return current_version_; }
 
  private:
   friend class ::ExtensionServiceTest;
   friend class ExtensionUpdaterTest;
   friend class ExtensionCrxInstallerTest;
 
@@ skipping 65 matching lines @@
   // and needs additional permissions.
   void ConfirmReEnable();
 
   void set_install_flag(int flag, bool val) {
     if (val)
       install_flags_ |= flag;
     else
       install_flags_ &= ~flag;
   }
 
+  // The Profile the extension is being installed in.
+  Profile* profile_;
+
+  // The extension being installed.
+  scoped_refptr<const Extension> extension_;
+
   // The file we're installing.
   base::FilePath source_file_;
 
   // The URL the file was downloaded from.
   GURL download_url_;
 
   // The directory extensions are installed to.
   const base::FilePath install_directory_;
 
   // The location the installation came from (bundled with Chromium, registry,
@@ skipping 130 matching lines @@
   ExtensionInstallPrompt::ShowDialogCallback show_dialog_callback_;
 
   // Whether the update is initiated by the user from the extension settings
   // page.
   bool update_from_settings_page_;
 
   // The flags for ExtensionService::OnExtensionInstalled.
   int install_flags_;
 
   // Performs requirements, policy and blacklist checks on the extension.
-  ExtensionInstallChecker install_checker_;
+  std::unique_ptr<ExtensionInstallChecker> install_checker_;

[Devlin, 2017/03/16 19:29:40]

optional: Truthfully, given the (lack of) complexity of ExtensionInstallChecker
to initialize, it's probably just as cheaper or cheaper overall to avoid the
heap allocation this requires.  But... this isn't performance sensitive code. 
So whichever you prefer.

If you opt for this route, you can remove the include and replace it with a
forward declaration.

[michaelpg, 2017/03/17 04:25:22]

I checked when I was considering using base::Optional (to avoid the heap
allocation). As a member, it'd add about 100 bytes to the class size. Not a ton,
but not trivial.

I like the pointer (or Optional) for the semantics of "this doesn't always
exist".
Done.

 
   DISALLOW_COPY_AND_ASSIGN(CrxInstaller);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_CRX_INSTALLER_H_