chromeos: Add VLOG(1)s around renderer-freezing for suspend.

chrome/browser/chromeos/power/renderer_freezer.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 "chrome/browser/chromeos/power/renderer_freezer.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 #include "extensions/browser/process_map.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 
 namespace chromeos {
 
 RendererFreezer::RendererFreezer(
     std::unique_ptr<RendererFreezer::Delegate> delegate)
     : delegate_(std::move(delegate)), weak_factory_(this) {
+  // TODO(derat): Remove after http://crbug.com/648580 is fixed.
+  VLOG(1) << "Creating RendererFreezer " << this;
   delegate_->CheckCanFreezeRenderers(
       base::Bind(&RendererFreezer::OnCheckCanFreezeRenderersComplete,
                  weak_factory_.GetWeakPtr()));
 }
 
 RendererFreezer::~RendererFreezer() {
+  // TODO(derat): Remove after http://crbug.com/648580 is fixed.
+  VLOG(1) << "Destroying RendererFreezer " << this;
   for (int rph_id : gcm_extension_processes_) {
     content::RenderProcessHost* host =
         content::RenderProcessHost::FromID(rph_id);
     if (host)
       host->RemoveObserver(this);
   }
 }
 
 void RendererFreezer::SuspendImminent() {
+  // TODO(derat): Remove after http://crbug.com/648580 is fixed.
+  VLOG(1) << "Asking delegate to freeze renderers";
   // All the delegate's operations are asynchronous so they may not complete
   // before the system suspends.  This is ok since the renderers only need to be
   // frozen in dark resume.  As long as they do get frozen soon after we enter
   // dark resume, there shouldn't be a problem.
   delegate_->FreezeRenderers();
 }
 
 void RendererFreezer::SuspendDone() {
+  // TODO(derat): Remove after http://crbug.com/648580 is fixed.
+  VLOG(1) << "Asking delegate to thaw renderers";
   delegate_->ThawRenderers(base::Bind(&RendererFreezer::OnThawRenderersComplete,
                                       weak_factory_.GetWeakPtr()));
 }
 
 void RendererFreezer::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED: {
       OnScreenLockStateChanged(
@@ skipping 53 matching lines @@
 
   registrar_.Add(this, chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(
       this,
       content::NOTIFICATION_RENDERER_PROCESS_CREATED,
       content::NotificationService::AllBrowserContextsAndSources());
 }
 
 void RendererFreezer::OnThawRenderersComplete(bool success) {
+  // TODO(derat): Remove after http://crbug.com/648580 is fixed.
+  VLOG(1) << "Thawing renderers complete";
   if (success)
     return;
 
   // We failed to write the thaw command and the renderers are still frozen.  We
   // are in big trouble because none of the tabs will be responsive so let's
   // crash the browser instead.
   LOG(FATAL) << "Unable to thaw renderers.";
 }
 
 void RendererFreezer::OnScreenLockStateChanged(chromeos::ScreenLocker* locker,
@@ skipping 57 matching lines @@
     rph->AddObserver(this);
     return;
   }
 
   // We didn't find an extension in this RenderProcessHost that is using GCM so
   // we can go ahead and freeze it on suspend.
   delegate_->SetShouldFreezeRenderer(rph->GetHandle(), true);
 }
 
 }  // namespace chromeos