Clear logging in Widevine CDM and default component installer

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 38 matching lines @@
 DefaultComponentInstaller::~DefaultComponentInstaller() {
 }
 
 void DefaultComponentInstaller::Register(
     ComponentUpdateService* cus,
     const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   task_runner_ = cus->GetSequencedTaskRunner();
 
   if (!installer_traits_) {
-    NOTREACHED() << "A DefaultComponentInstaller has been created but "
-                 << "has no installer traits.";
+    LOG(ERROR) << "A DefaultComponentInstaller has been created but "
+               << "has no installer traits.";
     return;
   }
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&DefaultComponentInstaller::StartRegistration,
                  this, cus),
       base::Bind(&DefaultComponentInstaller::FinishRegistration,
                  this, cus, callback));
 }
 
 void DefaultComponentInstaller::OnUpdateError(int error) {
-  NOTREACHED() << "Component update error: " << error;
+  LOG(ERROR) << "Component update error: " << error;
 }
 
 bool DefaultComponentInstaller::InstallHelper(
     const base::DictionaryValue& manifest,
     const base::FilePath& unpack_path,
     const base::FilePath& install_path) {
   VLOG(1) << "InstallHelper: unpack_path=" << unpack_path.AsUTF8Unsafe()
           << " install_path=" << install_path.AsUTF8Unsafe();
 
   if (!base::Move(unpack_path, install_path)) {
@@ skipping 62 matching lines @@
 }
 
 bool DefaultComponentInstaller::Uninstall() {
   DCHECK(thread_checker_.CalledOnValidThread());
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DefaultComponentInstaller::UninstallOnTaskRunner, this));
   return true;
 }
 
-// TODO(xhwang): The following LOG(WARNING) messages are added to help
-// investigate http://crbug.com/614745. Remove redundant checks or convent them
-// to VLOG(1) after investigation is completed.
 bool DefaultComponentInstaller::FindPreinstallation() {
   base::FilePath path;
   if (!PathService::Get(DIR_COMPONENT_PREINSTALLED, &path)) {
-    LOG(WARNING) << "DIR_COMPONENT_PREINSTALLED does not exist.";
+    DLOG(WARNING) << "DIR_COMPONENT_PREINSTALLED does not exist.";

[Sorin Jianu, 2016/06/02 19:30:10]

I've been using VLOG or DVLOG. My opinion is that it is annoying to see in the
debug log lines that come from some random module in Chrome and no ability to
control the logging.

[xhwang, 2016/06/02 20:02:18]

Done.

     return false;
   }
 
   path = path.Append(installer_traits_->GetRelativeInstallDir());
   if (!base::PathExists(path)) {
-    LOG(WARNING) << "Relative install dir does not exist: "
-                 << path.MaybeAsASCII();
+    DLOG(WARNING) << "Relative install dir does not exist: "
+                  << path.MaybeAsASCII();
     return false;
   }
 
   std::unique_ptr<base::DictionaryValue> manifest =
       update_client::ReadManifest(path);
   if (!manifest) {
-    LOG(WARNING) << "Manifest does not exist: " << path.MaybeAsASCII();
+    DLOG(WARNING) << "Manifest does not exist: " << path.MaybeAsASCII();
     return false;
   }
 
   if (!installer_traits_->VerifyInstallation(*manifest, path)) {
-    LOG(WARNING) << "Installation verification failed: " << path.MaybeAsASCII();
+    DLOG(WARNING) << "Installation verification failed: "
+                  << path.MaybeAsASCII();
     return false;
   }
 
   std::string version_lexical;
   if (!manifest->GetStringASCII("version", &version_lexical)) {
-    LOG(WARNING) << "Failed to get component version from the manifest.";
+    DLOG(WARNING) << "Failed to get component version from the manifest.";
     return false;
   }
 
   const base::Version version(version_lexical);
   if (!version.IsValid()) {
-    LOG(WARNING) << "Version in the manifest is invalid:" << version_lexical;
+    DLOG(WARNING) << "Version in the manifest is invalid:" << version_lexical;
     return false;
   }
 
-  LOG(WARNING) << "Preinstalled component found for "
-               << installer_traits_->GetName() << " at " << path.MaybeAsASCII()
-               << " with version " << version << ".";
+  VLOG(1) << "Preinstalled component found for " << installer_traits_->GetName()
+          << " at " << path.MaybeAsASCII() << " with version " << version
+          << ".";
 
   current_install_dir_ = path;
   current_manifest_ = std::move(manifest);
   current_version_ = version;
   return true;
 }
 
 void DefaultComponentInstaller::StartRegistration(ComponentUpdateService* cus) {
-  LOG(WARNING) << __FUNCTION__ << " for " << installer_traits_->GetName();
+  VLOG(1) << __FUNCTION__ << " for " << installer_traits_->GetName();
   DCHECK(task_runner_.get());
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   base::Version latest_version(kNullVersion);
 
   // First check for an installation set up alongside Chrome itself.
   if (FindPreinstallation())
     latest_version = current_version_;
 
   // Then check for a higher-versioned user-wide installation.
@@ skipping 95 matching lines @@
   // Delete the base directory if it's empty now.
   if (base::IsDirectoryEmpty(base_dir)) {
     if (base::DeleteFile(base_dir, false))
       DLOG(ERROR) << "Couldn't delete " << base_dir.value();
   }
 }
 
 void DefaultComponentInstaller::FinishRegistration(
     ComponentUpdateService* cus,
     const base::Closure& callback) {
-  LOG(WARNING) << __FUNCTION__ << " for " << installer_traits_->GetName();
+  VLOG(1) << __FUNCTION__ << " for " << installer_traits_->GetName();
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (installer_traits_->CanAutoUpdate()) {
     CrxComponent crx;
     crx.name = installer_traits_->GetName();
     crx.requires_network_encryption =
         installer_traits_->RequiresNetworkEncryption();
     crx.installer = this;
     crx.version = current_version_;
     crx.fingerprint = current_fingerprint_;
     installer_traits_->GetHash(&crx.pk_hash);
     if (!cus->RegisterComponent(crx)) {
-      LOG(WARNING) << "Component registration failed for "
-                   << installer_traits_->GetName();
+      LOG(ERROR) << "Component registration failed for "
+                 << installer_traits_->GetName();
       return;
     }
 
     if (!callback.is_null())
       callback.Run();
   }
 
   if (!current_manifest_) {
-    LOG(WARNING) << "No component found for " << installer_traits_->GetName();
+    DLOG(WARNING) << "No component found for " << installer_traits_->GetName();
     return;
   }
 
   std::unique_ptr<base::DictionaryValue> manifest_copy(
       current_manifest_->DeepCopy());
   ComponentReady(std::move(manifest_copy));
 }
 
 void DefaultComponentInstaller::ComponentReady(
     std::unique_ptr<base::DictionaryValue> manifest) {
   VLOG(1) << "Component ready, version " << current_version_.GetString()
           << " in " << current_install_dir_.value();
   installer_traits_->ComponentReady(current_version_, current_install_dir_,
                                     std::move(manifest));
 }
 
 }  // namespace component_updater