Allow the lid to be ignored using the use_lid pref

powerman.cc

 // Copyright (c) 2011 The Chromium OS 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 <stdlib.h>
 #include <stdio.h>
 #include <dbus/dbus-shared.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/vt.h>
@@ skipping 14 matching lines @@
 
 namespace power_manager {
 
 static const int kCheckLidClosedSeconds = 10;
 static const unsigned int kCancelDBusLidOpenedSecs = 5;
 
 PowerManDaemon::PowerManDaemon(PowerPrefs* prefs,
                                MetricsLibraryInterface* metrics_lib,
                                const FilePath& run_dir)
   : loop_(NULL),
+    use_input_for_lid_(1),
     prefs_(prefs),
     lidstate_(kLidOpened),
     metrics_lib_(metrics_lib),
     power_button_state_(false),
     retry_suspend_count_(0),
     suspend_pid_(0),
     lid_id_(0),
     powerd_id_(0),
     powerd_state_(kPowerManagerUnknown),
     run_dir_(run_dir),
     console_fd_(-1) {}
 
 PowerManDaemon::~PowerManDaemon() {
   if (console_fd_ >= 0) {
     close(console_fd_);
   }
 }
 
 void PowerManDaemon::Init() {
   int input_lidstate = 0;
+  int64 use_input_for_lid;
   CHECK(prefs_->GetInt64(kRetrySuspendMs, &retry_suspend_ms_));
   CHECK(prefs_->GetInt64(kRetrySuspendAttempts, &retry_suspend_attempts_));
+  CHECK(prefs_->GetInt64(kUseLid, &use_input_for_lid));
   // Retrys will occur no more than once a minute.
   CHECK_GE(retry_suspend_ms_, 60000);
   // Only 1-10 retries prior to just shutting down.
   CHECK_GT(retry_suspend_attempts_, 0);
   CHECK_LE(retry_suspend_attempts_, 10);
+  use_input_for_lid_ = 1 == use_input_for_lid;
   loop_ = g_main_loop_new(NULL, false);
   // Acquire a handle to the console for VT switch locking ioctl.
   CHECK(GetConsole());
   input_.RegisterHandler(&(PowerManDaemon::OnInputEvent), this);
   CHECK(input_.Init()) << "Cannot initialize input interface.";
   lid_open_file_ = FilePath(run_dir_).Append(util::kLidOpenFile);
   if (input_.num_lid_events() > 0) {
     input_.QueryLidState(&input_lidstate);
     lidstate_ = GetLidState(input_lidstate);
     lid_ticks_ = TimeTicks::Now();
@@ skipping 50 matching lines @@
     case LID: {
       daemon->lidstate_ = daemon->GetLidState(value);
       daemon->lid_id_++;
       daemon->lid_ticks_ = TimeTicks::Now();
       LOG(INFO) << "PowerM Daemon - lid "
                 << (daemon->lidstate_ == kLidClosed?"closed.":"opened.")
                 << " powerd "
                 << (daemon->powerd_state_ == kPowerManagerDead?
                     "dead":(daemon->powerd_state_ == kPowerManagerAlive?
                             "alive":"unknown"));
+      if (!daemon->use_input_for_lid_) {
+        LOG(INFO) << "Ignoring lid.";
+        break;
+      }
       if (daemon->lidstate_ == kLidClosed) {
         if (daemon->powerd_state_ != kPowerManagerAlive) {
           // powerd is not alive so act on its behalf.
           LOG(INFO) << "Forced suspend, powerd is not alive";
           daemon->Suspend();
         } else {
           util::SendSignalToPowerD(util::kLidClosed);
           // Check that powerd stuck around to act on  this event.  If not,
           // callback will assume suspend responsibilities.
           g_timeout_add_seconds(kCheckLidClosedSeconds, CheckLidClosedThunk,
@@ skipping 223 matching lines @@
     retval = false;
   }
   else {
     LOG(INFO) << "Opened console " << file_path.value().c_str()
               << " with file id = " << console_fd_;
   }
   return retval;
 }
 
 }  // namespace power_manager