Add some more logging to help diagnise component update issues.

components/component_updater/default_component_installer.cc

 // Copyright 2014 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 "components/component_updater/default_component_installer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 56 matching lines @@
 }
 
 void DefaultComponentInstaller::OnUpdateError(int error) {
   NOTREACHED() << "Component update error: " << error;
 }
 
 bool DefaultComponentInstaller::InstallHelper(
     const base::DictionaryValue& manifest,
     const base::FilePath& unpack_path,
     const base::FilePath& install_path) {
-  if (!base::Move(unpack_path, install_path))
+  VLOG(1) << "InstallHelper: unpack_path=" << unpack_path.AsUTF8Unsafe()
+          << " install_path=" << install_path.AsUTF8Unsafe();
+
+  if (!base::Move(unpack_path, install_path)) {
+    PLOG(ERROR) << "Move failed.";
     return false;
-  if (!installer_traits_->OnCustomInstall(manifest, install_path))
+  }
+  if (!installer_traits_->OnCustomInstall(manifest, install_path)) {
+    PLOG(ERROR) << "CustomInstall failed.";
     return false;
-  if (!installer_traits_->VerifyInstallation(manifest, install_path))
+  }
+  if (!installer_traits_->VerifyInstallation(manifest, install_path)) {
+    PLOG(ERROR) << "VerifyInstallation failed.";
     return false;
+  }
+
   return true;
 }
 
 bool DefaultComponentInstaller::Install(const base::DictionaryValue& manifest,
                                         const base::FilePath& unpack_path) {
   std::string manifest_version;
   manifest.GetStringASCII("version", &manifest_version);
   base::Version version(manifest_version);
+
+  VLOG(1) << "Install: version=" << version.GetString()
+          << " current version=" << current_version_.GetString();
+
   if (!version.IsValid())
     return false;
   if (current_version_.CompareTo(version) > 0)
     return false;
   base::FilePath install_path =
       installer_traits_->GetBaseDirectory().AppendASCII(version.GetString());
   if (base::PathExists(install_path)) {
     if (!base::DeleteFile(install_path, true))
       return false;
   }
@@ skipping 32 matching lines @@
       FROM_HERE,
       base::Bind(&DefaultComponentInstaller::UninstallOnTaskRunner, this));
   return true;
 }
 
 void DefaultComponentInstaller::StartRegistration(ComponentUpdateService* cus) {
   DCHECK(task_runner_.get());
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   base::FilePath base_dir = installer_traits_->GetBaseDirectory();
   if (!base::PathExists(base_dir) && !base::CreateDirectory(base_dir)) {
-    NOTREACHED() << "Could not create the base directory for "
-                 << installer_traits_->GetName() << " ("
-                 << base_dir.MaybeAsASCII() << ").";
+    PLOG(ERROR) << "Could not create the base directory for "
+                << installer_traits_->GetName() << " ("
+                << base_dir.MaybeAsASCII() << ").";
     return;
   }
 
   base::FilePath latest_path;
   base::Version latest_version(kNullVersion);
   scoped_ptr<base::DictionaryValue> latest_manifest;
 
   std::vector<base::FilePath> older_paths;
   base::FileEnumerator file_enumerator(
       base_dir, false, base::FileEnumerator::DIRECTORIES);
@@ skipping 10 matching lines @@
     // |version| not newer than the latest found version (kNullVersion if no
     // version has been found yet) is marked for removal.
     if (version.CompareTo(latest_version) <= 0) {
       older_paths.push_back(path);
       continue;
     }
 
     scoped_ptr<base::DictionaryValue> manifest =
         update_client::ReadManifest(path);
     if (!manifest || !installer_traits_->VerifyInstallation(*manifest, path)) {
-      DLOG(ERROR) << "Failed to read manifest or verify installation for "
-                  << installer_traits_->GetName() << " ("
-                  << path.MaybeAsASCII() << ").";
+      PLOG(ERROR) << "Failed to read manifest or verify installation for "
+                  << installer_traits_->GetName() << " (" << path.MaybeAsASCII()
+                  << ").";
       older_paths.push_back(path);
       continue;
     }
 
     // New valid |version| folder found!
 
     if (latest_manifest) {
       DCHECK(!latest_path.empty());
       older_paths.push_back(latest_path);
     }
@@ skipping 74 matching lines @@
   if (!current_manifest_)
     return;
 
   scoped_ptr<base::DictionaryValue> manifest_copy(
       current_manifest_->DeepCopy());
   ComponentReady(std::move(manifest_copy));
 }
 
 void DefaultComponentInstaller::ComponentReady(
     scoped_ptr<base::DictionaryValue> manifest) {
+  VLOG(1) << "ComponentReady";
   installer_traits_->ComponentReady(current_version_, GetInstallDirectory(),
                                     std::move(manifest));
 }
 
 }  // namespace component_updater