Fixes three crashes

athena/system/orientation_controller.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 "athena/screen/public/screen_manager.h"
 #include "athena/system/orientation_controller.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path_watcher.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 40 matching lines @@
 
     // Ambient light level in SI lux units.
     float light;
   };
 };
 
 }  // namespace
 
 OrientationController::OrientationController()
     : DeviceSocketListener(kSocketPath, sizeof(DeviceSensorEvent)),
-      last_orientation_change_time_(0) {
+      last_orientation_change_time_(0),
+      shutdown_(false) {
   CHECK(base::MessageLoopForUI::current());
   ui_task_runner_ = base::MessageLoopForUI::current()->task_runner();
 }
 
 void OrientationController::InitWith(
-    scoped_refptr<base::TaskRunner> io_task_runner) {
-  io_task_runner->PostTask(FROM_HERE, base::Bind(
-      &OrientationController::WatchForSocketPathOnIO, this));
+    scoped_refptr<base::TaskRunner> file_task_runner) {
+  file_task_runner_ = file_task_runner;
+  file_task_runner->PostTask(
+      FROM_HERE,
+      base::Bind(&OrientationController::WatchForSocketPathOnFILE, this));
 }
 
 OrientationController::~OrientationController() {
 }
 
-void OrientationController::WatchForSocketPathOnIO() {
+void OrientationController::Shutdown() {
+  CHECK(file_task_runner_);
+  StopListening();
+  file_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&OrientationController::ShutdownOnFILE, this));
+}
+
+void OrientationController::ShutdownOnFILE() {
+  shutdown_ = true;
+  watcher_.reset();
+}
+
+void OrientationController::WatchForSocketPathOnFILE() {
   CHECK(base::MessageLoopForIO::current());
   if (base::PathExists(base::FilePath(kSocketPath))) {
     ui_task_runner_->PostTask(FROM_HERE,
         base::Bind(&OrientationController::StartListening, this));
   } else {
     watcher_.reset(new base::FilePathWatcher);
     watcher_->Watch(
-        base::FilePath(kSocketPath), false,
-        base::Bind(&OrientationController::OnFilePathChangedOnIO, this));
+        base::FilePath(kSocketPath),
+        false,
+        base::Bind(&OrientationController::OnFilePathChangedOnFILE, this));
   }
 }
 
-void OrientationController::OnFilePathChangedOnIO(const base::FilePath& path,
-                                                  bool error) {
+void OrientationController::OnFilePathChangedOnFILE(const base::FilePath& path,
+                                                    bool error) {
   watcher_.reset();
-  if (error)
+  if (error || shutdown_)

[flackr, 2014/08/21 15:07:22]

Not sure this check of shutdown_ is necessary. Since ShutdownOnFILE which sets
shutdown_ runs on the same thread and destructs the watcher I don't think this
can be called if it is shutdown_.

[oshima, 2014/08/21 16:41:00]

FilePathWatcherImpl, which really watches the file, seems to outlive
FilePathWatcher. This won't really happen in real scenario, but this is to make
sure it wont cause an problem in test or desktop.

     return;
 
   ui_task_runner_->PostTask(FROM_HERE,
       base::Bind(&OrientationController::StartListening, this));
 }
 
-void OrientationController::OnDataAvailableOnIO(const void* data) {
+void OrientationController::OnDataAvailableOnFILE(const void* data) {
   const DeviceSensorEvent* event =
       static_cast<const DeviceSensorEvent*>(data);
   if (event->type != SENSOR_ACCELEROMETER)
     return;
 
   float gravity_x = event->data[0];
   float gravity_y = event->data[1];
   gfx::Display::Rotation rotation;
   if (gravity_x < -kGravityThreshold) {
     rotation = gfx::Display::ROTATE_270;
@@ skipping 15 matching lines @@
   }
 
   last_orientation_change_time_ = event->timestamp;
   current_rotation_ = rotation;
   ui_task_runner_->PostTask(FROM_HERE,
       base::Bind(&OrientationController::RotateOnUI, this, rotation));
 }
 
 void OrientationController::RotateOnUI(gfx::Display::Rotation rotation) {
   ScreenManager* screen_manager = ScreenManager::Get();
-  // Since this is called from the IO thread, the screen manager may no longer
+  // Since this is called from the FILE thread, the screen manager may no longer
   // exist.
   if (screen_manager)
     screen_manager->SetRotation(rotation);
 }
 
 }  // namespace athena