chromeos: Avoid crash on thaw failure if freezing failed.

chrome/browser/chromeos/power/freezer_cgroup_process_manager.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/freezer_cgroup_process_manager.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 16 matching lines @@
 const char kThawCommand[] = "THAWED";
 
 }  // namespace
 
 class FreezerCgroupProcessManager::FileWorker {
  public:
   // Called on UI thread.
   explicit FileWorker(scoped_refptr<base::SequencedTaskRunner> file_thread)
       : ui_thread_(content::BrowserThread::GetTaskRunnerForThread(
             content::BrowserThread::UI)),
-        file_thread_(file_thread) {
+        file_thread_(file_thread),
+        enabled_(false),
+        froze_successfully_(false) {
     DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   }
 
   // Called on FILE thread.
   virtual ~FileWorker() { DCHECK(file_thread_->RunsTasksOnCurrentThread()); }
 
   void Start() {
     DCHECK(file_thread_->RunsTasksOnCurrentThread());
 
     default_control_path_ = base::FilePath(kFreezerPath).Append(kCgroupProcs);
@@ skipping 23 matching lines @@
 
   void FreezeRenderers() {
     DCHECK(file_thread_->RunsTasksOnCurrentThread());
 
     if (!enabled_) {
       LOG(ERROR) << "Attempting to freeze renderers when the freezer cgroup is "
                  << "not available.";
       return;
     }
 
-    WriteCommandToFile(kFreezeCommand, to_be_frozen_state_path_);
+    froze_successfully_ =
+        WriteCommandToFile(kFreezeCommand, to_be_frozen_state_path_);
   }
 
   void ThawRenderers(ResultCallback callback) {
     DCHECK(file_thread_->RunsTasksOnCurrentThread());
 
     if (!enabled_) {
       LOG(ERROR) << "Attempting to thaw renderers when the freezer cgroup is "
                  << "not available.";
       return;
     }
 
     bool result = WriteCommandToFile(kThawCommand, to_be_frozen_state_path_);
+
+    // TODO(derat): For now, lie and report success if thawing failed but
+    // freezing also failed previously. Remove after weird EBADF and ENOENT
+    // problems tracked at http://crbug.com/661310 are fixed.
+    if (!result && !froze_successfully_)
+      result = true;
+
     ui_thread_->PostTask(FROM_HERE, base::Bind(callback, result));
   }
 
   void CheckCanFreezeRenderers(ResultCallback callback) {
     DCHECK(file_thread_->RunsTasksOnCurrentThread());
 
     ui_thread_->PostTask(FROM_HERE, base::Bind(callback, enabled_));
   }
 
  private:
@@ skipping 17 matching lines @@
 
   // Control path for the cgroup that is not frozen.
   base::FilePath default_control_path_;
 
   // Control and state paths for the cgroup whose processes will be frozen.
   base::FilePath to_be_frozen_control_path_;
   base::FilePath to_be_frozen_state_path_;
 
   bool enabled_;
 
+  // True iff FreezeRenderers() wrote its command successfully the last time it
+  // was called.
+  bool froze_successfully_;
+
   DISALLOW_COPY_AND_ASSIGN(FileWorker);
 };
 
 FreezerCgroupProcessManager::FreezerCgroupProcessManager()
     : file_thread_(content::BrowserThread::GetTaskRunnerForThread(
           content::BrowserThread::FILE)),
       file_worker_(new FileWorker(file_thread_)) {
   file_thread_->PostTask(FROM_HERE,
                          base::Bind(&FileWorker::Start,
                                     base::Unretained(file_worker_.get())));
@@ skipping 27 matching lines @@
 
 void FreezerCgroupProcessManager::CheckCanFreezeRenderers(
     ResultCallback callback) {
   file_thread_->PostTask(FROM_HERE,
                          base::Bind(&FileWorker::CheckCanFreezeRenderers,
                                     base::Unretained(file_worker_.get()),
                                     callback));
 }
 
 }  // namespace chromeos