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.";
+    DVLOG(1) << "DIR_COMPONENT_PREINSTALLED does not exist.";
     return false;
   }
 
   path = path.Append(installer_traits_->GetRelativeInstallDir());
   if (!base::PathExists(path)) {
-    LOG(WARNING) << "Relative install dir does not exist: "
-                 << path.MaybeAsASCII();
+    DVLOG(1) << "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();
+    DVLOG(1) << "Manifest does not exist: " << path.MaybeAsASCII();
     return false;
   }
 
   if (!installer_traits_->VerifyInstallation(*manifest, path)) {
-    LOG(WARNING) << "Installation verification failed: " << path.MaybeAsASCII();
+    DVLOG(1) << "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.";
+    DVLOG(1) << "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;
+    DVLOG(1) << "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();
+    DVLOG(1) << "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