Add some more logging to help diagnise component update issues.

chrome/browser/component_updater/widevine_cdm_component_installer.cc

 // Copyright (c) 2013 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/widevine_cdm_component_installer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <string>
@@ skipping 262 matching lines @@
     const base::FilePath& install_dir) {
   return true;
 }
 
 // Once the CDM is ready, check the CDM adapter.
 void WidevineCdmComponentInstallerTraits::ComponentReady(
     const base::Version& version,
     const base::FilePath& path,
     scoped_ptr<base::DictionaryValue> manifest) {
   if (!IsCompatibleWithChrome(*manifest)) {
-    DLOG(WARNING) << "Installed Widevine CDM component is incompatible.";
+    VLOG(1) << "Installed Widevine CDM component is incompatible.";
     return;
   }
 
   BrowserThread::PostBlockingPoolTask(
       FROM_HERE,
       base::Bind(&WidevineCdmComponentInstallerTraits::UpdateCdmAdapter,
                  base::Unretained(this),
                  version,
                  path,
                  base::Passed(&manifest)));
 }
 
 bool WidevineCdmComponentInstallerTraits::VerifyInstallation(
     const base::DictionaryValue& manifest,
     const base::FilePath& install_dir) const {
   return IsCompatibleWithChrome(manifest) &&
          base::PathExists(GetPlatformDirectory(install_dir)
                               .AppendASCII(kWidevineCdmFileName));

[xhwang, 2016/03/24 00:22:54]

Do we want to log if this returns false?

[Sorin Jianu, 2016/03/24 00:41:24]

We do. It is logged by the implementation of the default component installer at
line 89.

Where possible, I tried to avoid duplicating log statements in the release
build.

[xhwang, 2016/03/24 00:52:04]

Got it. Thanks!

 }
 
 // The base directory on Windows looks like:
 // <profile>\AppData\Local\Google\Chrome\User Data\WidevineCdm\.
 base::FilePath WidevineCdmComponentInstallerTraits::GetBaseDirectory() const {
   base::FilePath result;
   PathService::Get(chrome::DIR_COMPONENT_WIDEVINE_CDM, &result);
   return result;
 }
 
 void WidevineCdmComponentInstallerTraits::GetHash(
     std::vector<uint8_t>* hash) const {
   hash->assign(kSha2Hash, kSha2Hash + arraysize(kSha2Hash));
 }
 
 std::string WidevineCdmComponentInstallerTraits::GetName() const {
   return kWidevineCdmDisplayName;
 }
 
 void WidevineCdmComponentInstallerTraits::UpdateCdmAdapter(
     const base::Version& cdm_version,
     const base::FilePath& cdm_install_dir,
     scoped_ptr<base::DictionaryValue> manifest) {
   const base::FilePath adapter_version_path =
       GetPlatformDirectory(cdm_install_dir).AppendASCII(kCdmAdapterVersionName);
   const base::FilePath adapter_install_path =
       GetPlatformDirectory(cdm_install_dir)
           .AppendASCII(kWidevineCdmAdapterFileName);
 
+  VLOG(1) << "UpdateCdmAdapter: version" << cdm_version.GetString()
+          << " adapter_install_path=" << adapter_install_path.AsUTF8Unsafe()
+          << " adapter_version_path=" << adapter_version_path.AsUTF8Unsafe();
+
   const std::string chrome_version = version_info::GetVersionNumber();
   DCHECK(!chrome_version.empty());
   std::string adapter_version;
   if (!base::ReadFileToString(adapter_version_path, &adapter_version) ||
       adapter_version != chrome_version ||
       !base::PathExists(adapter_install_path)) {
     int bytes_written = base::WriteFile(
         adapter_version_path, chrome_version.data(), chrome_version.size());
     if (bytes_written < 0 ||
         static_cast<size_t>(bytes_written) != chrome_version.size()) {
-      DLOG(WARNING) << "Failed to write Widevine CDM adapter version file.";
+      PLOG(WARNING) << "Failed to write Widevine CDM adapter version file.";
       // Ignore version file writing failure and try to copy the CDM adapter.
     }
 
     base::FilePath adapter_source_path;
     PathService::Get(chrome::FILE_WIDEVINE_CDM_ADAPTER, &adapter_source_path);
     if (!base::CopyFile(adapter_source_path, adapter_install_path)) {
-      DLOG(WARNING) << "Failed to copy Widevine CDM adapter.";
+      PLOG(WARNING) << "Failed to copy Widevine CDM adapter.";
       return;
     }
   }
 
   BrowserThread::PostTask(content::BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&RegisterWidevineCdmWithChrome,
                                      cdm_version,
                                      adapter_install_path,
                                      base::Passed(&manifest)));
@@ skipping 10 matching lines @@
   scoped_ptr<ComponentInstallerTraits> traits(
       new WidevineCdmComponentInstallerTraits);
   // |cus| will take ownership of |installer| during installer->Register(cus).
   DefaultComponentInstaller* installer =
       new DefaultComponentInstaller(std::move(traits));
   installer->Register(cus, base::Closure());
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
 }
 
 }  // namespace component_updater