Hold cros_component_installers in browser_process.

chrome/browser/component_updater/cros_component_installer.cc

 // Copyright 2017 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/component_updater/cros_component_installer.h"
 #include "base/task_scheduler/post_task.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/component_installer_errors.h"
 #include "components/component_updater/component_updater_paths.h"
 #include "components/crx_file/id_util.h"
@@ skipping 110 matching lines @@
   attrs["_env_version"] = env_version;
   return attrs;
 }
 
 std::vector<std::string> CrOSComponentInstallerTraits::GetMimeTypes() const {
   std::vector<std::string> mime_types;
   return mime_types;
 }
 
 void CrOSComponent::RegisterCrOSComponentInternal(
+    const std::string& name,
     ComponentUpdateService* cus,
     const ComponentConfig& config,
     const base::Closure& installcallback) {
   std::unique_ptr<ComponentInstallerTraits> traits(
       new CrOSComponentInstallerTraits(config));
   // |cus| will take ownership of |installer| during

[sky, 2017/05/23 23:20:30]

Update comment?

Also, I'm rather confused about the ownership model. I don't see any other
changes to CrOSComponentInstallerTraits, so how is it that the installer created
by GetCrosComponentInstaller() isn't destroyed like this comment implies it was?

[xiaochu, 2017/05/23 23:40:52]

Done.

   // installer->Register(cus).
-  DefaultComponentInstaller* installer =
-      new DefaultComponentInstaller(std::move(traits));
+  scoped_refptr<DefaultComponentInstaller> installer =
+      g_browser_process->platform_part()->GetCrosComponentInstaller(
+          name, std::move(traits));
   installer->Register(cus, installcallback);
 }
 
 void CrOSComponent::InstallChromeOSComponent(
     ComponentUpdateService* cus,
     const std::string& id,
     const update_client::Callback& install_callback) {
   cus->GetOnDemandUpdater().OnDemandUpdate(id, install_callback);
 }
 
@@ skipping 17 matching lines @@
     DVLOG(1) << "[RegisterCrOSComponents] component " << name
              << " is not in configuration.";
     base::PostTask(
         FROM_HERE,
         base::Bind(install_callback, update_client::Error::INVALID_ARGUMENT));
     return false;
   }
   ComponentConfig config(it->first, it->second.find("env_version")->second,
                          it->second.find("sha2hashstr")->second);
   RegisterCrOSComponentInternal(
-      cus, config,
+      name, cus, config,
       base::Bind(InstallChromeOSComponent, cus,
                  crx_file::id_util::GenerateIdFromHex(
                      it->second.find("sha2hashstr")->second)
                      .substr(0, 32),
                  install_callback));
   return true;
 }
 
 void MountResult(const base::Callback<void(const std::string&)>& mount_callback,
                  chromeos::DBusMethodCallStatus call_status,
@@ skipping 18 matching lines @@
       chromeos::DBusThreadManager::Get()->GetImageLoaderClient();
   if (loader) {
     loader->LoadComponent(name, base::Bind(&MountResult, mount_callback));
   } else {
     DVLOG(1) << "Failed to get ImageLoaderClient object.";
   }
 }
 #endif  // defined(OS_CHROMEOS
 
 }  // namespace component_updater