chromeos: output_configurator: various style fixes

chromeos/display/output_configurator.cc

 // Copyright (c) 2012 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 "chromeos/display/output_configurator.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/Xrandr.h>
 
@@ skipping 204 matching lines @@
 static float ComputeDeviceScaleFactor(unsigned int width,
                                       unsigned long mm_width) {
   float device_scale_factor = 1.0f;
   if (mm_width > 0 && (kMmInInch * width / mm_width) > kHighDensityDIPThreshold)
     device_scale_factor = 2.0f;
   return device_scale_factor;
 }
 
 }  // namespace
 
+OutputConfigurator::OutputConfigurator()
+    : is_running_on_chrome_os_(base::chromeos::IsRunningOnChromeOS()),
+      output_count_(0),
+      output_cache_(NULL),
+      mirror_supported_(false),
+      primary_output_index_(-1),
+      secondary_output_index_(-1),
+      xrandr_event_base_(0),
+      output_state_(STATE_INVALID) {
+  if (!is_running_on_chrome_os_)
+    return;
+  // Send the signal to powerd to tell it that we will take over output
+  // control.
+  // Note that this can be removed once the legacy powerd support is removed.
+  chromeos::DBusThreadManager* manager = chromeos::DBusThreadManager::Get();
+  dbus::Bus* bus = manager->GetSystemBus();
+  dbus::ExportedObject* remote_object = bus->GetExportedObject(
+      dbus::ObjectPath(power_manager::kPowerManagerServicePath));
+  dbus::Signal signal(power_manager::kPowerManagerInterface,
+                      power_manager::kUseNewMonitorConfigSignal);
+  CHECK(signal.raw_message() != NULL);
+  remote_object->SendSignal(&signal);
+
+  // Cache the initial output state.
+  Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
+  CHECK(display != NULL);
+  XGrabServer(display);
+  Window window = DefaultRootWindow(display);
+  XRRScreenResources* screen = XRRGetScreenResources(display, window);
+  CHECK(screen != NULL);
+  bool did_detect_outputs = TryRecacheOutputs(display, screen);
+  CHECK(did_detect_outputs);
+  OutputState current_state = InferCurrentState(display, screen);
+  if (current_state == STATE_INVALID) {
+    // Unknown state.  Transition into the default state.
+    OutputState state = GetDefaultState();
+    UpdateCacheAndXrandrToState(display, screen, window, state);
+  } else {
+    // This is a valid state so just save it to |output_state_|.
+    output_state_ = current_state;
+  }
+  // Find xrandr_event_base_ since we need it to interpret events, later.
+  int error_base_ignored = 0;
+  XRRQueryExtension(display, &xrandr_event_base_, &error_base_ignored);
+  // Relinquish X resources.
+  XRRFreeScreenResources(screen);
+  XUngrabServer(display);
+  CheckIsProjectingAndNotify();
+}
+
+OutputConfigurator::~OutputConfigurator() {
+}
+
+bool OutputConfigurator::CycleDisplayMode(bool extended_desktop_enabled) {
+  VLOG(1) << "CycleDisplayMode";
+  if (!is_running_on_chrome_os_)
+    return false;
+
+  bool did_change = false;
+  // Rules:
+  // - if there are 0 or 1 displays, do nothing and return false.
+  // - use y-coord of CRTCs to determine if we are mirror, primary-first, or
+  // secondary-first.  The cycle order is:
+  //   mirror->primary->secondary->mirror.
+  // Note: If the extended desktop is enabled, the cycle order becomes,
+  // mirror->extended->mirror
+  OutputState new_state = STATE_INVALID;
+  switch (output_state_) {
+    case STATE_DUAL_MIRROR:
+      new_state = STATE_DUAL_PRIMARY_ONLY;
+      break;
+    case STATE_DUAL_PRIMARY_ONLY:
+      if (extended_desktop_enabled) {
+        if (mirror_supported_)
+          new_state = STATE_DUAL_MIRROR;
+        else
+          new_state = STATE_INVALID;
+      } else {
+        new_state = STATE_DUAL_SECONDARY_ONLY;
+      }
+      break;
+    case STATE_DUAL_SECONDARY_ONLY:
+      new_state = mirror_supported_ ?
+          STATE_DUAL_MIRROR :
+          STATE_DUAL_PRIMARY_ONLY;
+      break;
+    default:
+      // Do nothing - we aren't in a mode which we can rotate.
+      break;
+  }
+  if (STATE_INVALID != new_state)
+    did_change = SetDisplayMode(new_state);
+
+  return did_change;
+}
+
+bool OutputConfigurator::ScreenPowerSet(bool power_on, bool all_displays) {
+  VLOG(1) << "OutputConfigurator::SetScreensOn " << power_on
+          << " all displays " << all_displays;
+  if (!is_running_on_chrome_os_)
+    return false;
+
+  bool success = false;
+  Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
+  CHECK(display != NULL);
+  XGrabServer(display);
+  Window window = DefaultRootWindow(display);
+  XRRScreenResources* screen = XRRGetScreenResources(display, window);
+  CHECK(screen != NULL);
+
+  // Set the CRTCs based on whether we want to turn the power on or off and
+  // select the outputs to operate on by name or all_displays.
+  for (int i = 0; i < output_count_; ++i) {
+    if (all_displays || output_cache_[i].is_internal) {
+      const int x = output_cache_[i].x;
+      const int y = output_cache_[i].y;
+      RROutput output = output_cache_[i].output;
+      RRCrtc crtc = output_cache_[i].crtc;
+      RRMode mode = None;
+      if (power_on) {
+        mode = (STATE_DUAL_MIRROR == output_state_) ?
+            output_cache_[i].mirror_mode :
+            output_cache_[i].ideal_mode;
+      }
+
+      VLOG(1) << "SET POWER crtc: " << crtc
+              << ", mode " << mode
+              << ", output " << output
+              << ", x " << x
+              << ", y " << y;
+      // The values we are setting are already from the cache so no update
+      // required.
+      ConfigureCrtc(display,
+                    screen,
+                    crtc,
+                    x,
+                    y,
+                    mode,
+                    output);
+      output_cache_[i].is_powered_on = power_on;
+      success = true;
+    }
+  }
+
+  // Force the DPMS on since the driver doesn't always detect that it should
+  // turn on.
+  if (power_on) {
+    CHECK(DPMSEnable(display));
+    CHECK(DPMSForceLevel(display, DPMSModeOn));
+  }
+
+  XRRFreeScreenResources(screen);
+  XUngrabServer(display);
+
+  return success;
+}
+
+bool OutputConfigurator::SetDisplayMode(OutputState new_state) {
+  if (output_state_ == STATE_INVALID ||
+      output_state_ == STATE_HEADLESS ||
+      output_state_ == STATE_SINGLE)
+    return false;
+
+  Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
+  CHECK(display != NULL);
+  XGrabServer(display);
+  Window window = DefaultRootWindow(display);
+  XRRScreenResources* screen = XRRGetScreenResources(display, window);
+  CHECK(screen != NULL);
+
+  UpdateCacheAndXrandrToState(display,
+                              screen,
+                              window,
+                              new_state);
+  XRRFreeScreenResources(screen);
+  XUngrabServer(display);
+  return true;
+}
+
+bool OutputConfigurator::Dispatch(const base::NativeEvent& event) {
+  // Ignore this event if the Xrandr extension isn't supported.
+  if (!is_running_on_chrome_os_ ||
+      (event->type - xrandr_event_base_ != RRNotify)) {
+    return true;
+  }
+  XEvent* xevent = static_cast<XEvent*>(event);
+  XRRNotifyEvent* notify_event =
+      reinterpret_cast<XRRNotifyEvent*>(xevent);
+  if (notify_event->subtype == RRNotify_OutputChange) {
+    XRROutputChangeNotifyEvent* output_change_event =
+        reinterpret_cast<XRROutputChangeNotifyEvent*>(xevent);
+    if ((output_change_event->connection == RR_Connected) ||
+        (output_change_event->connection == RR_Disconnected)) {
+      RecacheAndUseDefaultState();
+      CheckIsProjectingAndNotify();
+    }
+    // Ignore the case of RR_UnkownConnection.
+  }
+  return true;
+}
+
 bool OutputConfigurator::TryRecacheOutputs(Display* display,
                                            XRRScreenResources* screen) {
   bool outputs_did_change = false;
   int previous_connected_count = 0;
   int new_connected_count = 0;
 
   if (output_count_ != screen->noutput) {
     outputs_did_change = true;
   } else {
     // The outputs might have changed so compare the connected states in the
     // screen to our existing cache.
     for (int i = 0; (i < output_count_) && !outputs_did_change; ++i) {
       RROutput thisID = screen->outputs[i];
       XRROutputInfo* output = XRRGetOutputInfo(display, screen, thisID);
       bool now_connected = (RR_Connected == output->connection);
       outputs_did_change = (now_connected != output_cache_[i].is_connected);
       XRRFreeOutputInfo(output);
 
       if (output_cache_[i].is_connected)
         previous_connected_count += 1;
       if (now_connected)
         new_connected_count += 1;
     }
   }
 
-  if (outputs_did_change) {
-    // We now know that we need to recache so free and re-alloc the buffer.
-    output_count_ = screen->noutput;
-    if (output_count_ == 0) {
-      output_cache_.reset(NULL);
-    } else {
-      // Ideally, this would be allocated inline in the OutputConfigurator
-      // instance since we support at most 2 connected outputs but this dynamic
-      // allocation was specifically requested.
-      output_cache_.reset(new CachedOutputDescription[output_count_]);
+  if (!outputs_did_change)
+    return false;
+  // We now know that we need to recache so free and re-alloc the buffer.
+  output_count_ = screen->noutput;
+  if (output_count_ == 0) {
+    output_cache_.reset(NULL);
+  } else {
+    // Ideally, this would be allocated inline in the OutputConfigurator
+    // instance since we support at most 2 connected outputs but this dynamic
+    // allocation was specifically requested.
+    output_cache_.reset(new CachedOutputDescription[output_count_]);
+  }
+
+  // TODO: This approach to finding CRTCs only supports two.  Expand on this.
+  RRCrtc used_crtc = None;
+  primary_output_index_ = -1;
+  secondary_output_index_ = -1;
+
+  for (int i = 0; i < output_count_; ++i) {
+    RROutput this_id = screen->outputs[i];
+    XRROutputInfo* output = XRRGetOutputInfo(display, screen, this_id);
+    bool is_connected = (RR_Connected == output->connection);
+    RRCrtc crtc = None;
+    RRMode ideal_mode = None;
+    int x = 0;
+    int y = 0;
+    unsigned long mm_width = output->mm_width;
+    unsigned long mm_height = output->mm_height;
+    bool is_internal = false;
+
+    if (is_connected) {
+      for (int j = 0; (j < output->ncrtc) && (None == crtc); ++j) {
+        RRCrtc possible = output->crtcs[j];
+        if (possible != used_crtc) {
+          crtc = possible;
+          used_crtc = possible;
+        }
+      }
+
+      const char* name = output->name;
+      is_internal =
+          (strncmp(kInternal_LVDS,
+                   name,
+                   arraysize(kInternal_LVDS) - 1) == 0) ||
+          (strncmp(kInternal_eDP,
+                   name,
+                   arraysize(kInternal_eDP) - 1) == 0);
+      if (output->nmode > 0)
+        ideal_mode = output->modes[0];
+
+      if (crtc != None) {
+        XRRCrtcInfo* crtcInfo = XRRGetCrtcInfo(display, screen, crtc);
+        x = crtcInfo->x;
+        y = crtcInfo->y;
+        XRRFreeCrtcInfo(crtcInfo);
+      }
+
+      // Save this for later mirror mode detection.
+      if (primary_output_index_ == -1)
+        primary_output_index_ = i;
+      else if (secondary_output_index_ == -1)
+        secondary_output_index_ = i;
     }
+    XRRFreeOutputInfo(output);
 
-    // TODO: This approach to finding CRTCs only supports two.  Expand on this.
-    RRCrtc used_crtc = None;
-    primary_output_index_ = -1;
-    secondary_output_index_ = -1;
+    // Now save the cached state for this output (we will default to mirror
+    // disabled and detect that after we have identified the first two
+    // connected outputs).
+    VLOG(1) << "Recache output index: " << i
+            << ", output id: " << this_id
+            << ", crtc id: " << crtc
+            << ", ideal mode id: " << ideal_mode
+            << ", x: " << x
+            << ", y: " << y
+            << ", is connected: " << is_connected
+            << ", is_internal: " << is_internal
+            << ", mm_width: " << mm_width
+            << ", mm_height: " << mm_height;
+    output_cache_[i].output = this_id;
+    output_cache_[i].crtc = crtc;
+    output_cache_[i].mirror_mode = None;
+    output_cache_[i].ideal_mode = ideal_mode;
+    output_cache_[i].x = x;
+    output_cache_[i].y = y;
+    output_cache_[i].is_connected = is_connected;
+    output_cache_[i].is_powered_on = true;
+    output_cache_[i].is_internal = is_internal;
+    output_cache_[i].mm_width = mm_width;
+    output_cache_[i].mm_height = mm_height;
+  }
 
-    for (int i = 0; i < output_count_; ++i) {
-      RROutput this_id = screen->outputs[i];
-      XRROutputInfo* output = XRRGetOutputInfo(display, screen, this_id);
-      bool is_connected = (RR_Connected == output->connection);
-      RRCrtc crtc = None;
-      RRMode ideal_mode = None;
-      int x = 0;
-      int y = 0;
-      unsigned long mm_width = output->mm_width;
-      unsigned long mm_height = output->mm_height;
-      bool is_internal = false;
+  // Now, detect the mirror modes if we have two connected outputs.
+  if ((primary_output_index_ != -1) && (secondary_output_index_ != -1)) {
+    mirror_supported_ = FindMirrorModeForOutputs(
+        display,
+        screen,
+        output_cache_[primary_output_index_].output,
+        output_cache_[secondary_output_index_].output,
+        &output_cache_[primary_output_index_].mirror_mode,
+        &output_cache_[secondary_output_index_].mirror_mode);
 
-      if (is_connected) {
-        for (int j = 0; (j < output->ncrtc) && (None == crtc); ++j) {
-          RRCrtc possible = output->crtcs[j];
-          if (possible != used_crtc) {
-            crtc = possible;
-            used_crtc = possible;
-          }
-        }
-
-        const char* name = output->name;
-        is_internal =
-            (strncmp(kInternal_LVDS,
-                     name,
-                     arraysize(kInternal_LVDS) - 1) == 0) ||
-            (strncmp(kInternal_eDP,
-                     name,
-                     arraysize(kInternal_eDP) - 1) == 0);
-        if (output->nmode > 0)
-          ideal_mode = output->modes[0];
-
-        if (crtc != None) {
-          XRRCrtcInfo* crtcInfo = XRRGetCrtcInfo(display, screen, crtc);
-          x = crtcInfo->x;
-          y = crtcInfo->y;
-          XRRFreeCrtcInfo(crtcInfo);
-        }
-
-        // Save this for later mirror mode detection.
-        if (primary_output_index_ == -1)
-          primary_output_index_ = i;
-        else if (secondary_output_index_ == -1)
-          secondary_output_index_ = i;
-      }
-      XRRFreeOutputInfo(output);
-
-      // Now save the cached state for this output (we will default to mirror
-      // disabled and detect that after we have identified the first two
-      // connected outputs).
-      VLOG(1) << "Recache output index: " << i
-              << ", output id: " << this_id
-              << ", crtc id: " << crtc
-              << ", ideal mode id: " << ideal_mode
-              << ", x: " << x
-              << ", y: " << y
-              << ", is connected: " << is_connected
-              << ", is_internal: " << is_internal
-              << ", mm_width: " << mm_width
-              << ", mm_height: " << mm_height;
-      output_cache_[i].output = this_id;
-      output_cache_[i].crtc = crtc;
-      output_cache_[i].mirror_mode = None;
-      output_cache_[i].ideal_mode = ideal_mode;
-      output_cache_[i].x = x;
-      output_cache_[i].y = y;
-      output_cache_[i].is_connected = is_connected;
-      output_cache_[i].is_powered_on = true;
-      output_cache_[i].is_internal = is_internal;
-      output_cache_[i].mm_width = mm_width;
-      output_cache_[i].mm_height = mm_height;
-    }
-
-    // Now, detect the mirror modes if we have two connected outputs.
-    if ((primary_output_index_ != -1) && (secondary_output_index_ != -1)) {
-      mirror_supported_ = FindMirrorModeForOutputs(
-          display,
-          screen,
-          output_cache_[primary_output_index_].output,
-          output_cache_[secondary_output_index_].output,
-          &output_cache_[primary_output_index_].mirror_mode,
-          &output_cache_[secondary_output_index_].mirror_mode);
-
-      RRMode primary_mode = output_cache_[primary_output_index_].mirror_mode;
-      RRMode second_mode = output_cache_[secondary_output_index_].mirror_mode;
-      VLOG(1) << "Mirror mode supported " << mirror_supported_
-              << " primary " << primary_mode
-              << " secondary " << second_mode;
-    }
+    RRMode primary_mode = output_cache_[primary_output_index_].mirror_mode;
+    RRMode second_mode = output_cache_[secondary_output_index_].mirror_mode;
+    VLOG(1) << "Mirror mode supported " << mirror_supported_
+            << " primary " << primary_mode
+            << " secondary " << second_mode;
   }
   return outputs_did_change;
 }
 
-OutputConfigurator::OutputConfigurator()
-    : is_running_on_chrome_os_(base::chromeos::IsRunningOnChromeOS()),
-      output_count_(0),
-      output_cache_(NULL),
-      mirror_supported_(false),
-      primary_output_index_(-1),
-      secondary_output_index_(-1),
-      xrandr_event_base_(0),
-      output_state_(STATE_INVALID) {
-  if (is_running_on_chrome_os_) {
-    // Send the signal to powerd to tell it that we will take over output
-    // control.
-    // Note that this can be removed once the legacy powerd support is removed.
-    chromeos::DBusThreadManager* manager = chromeos::DBusThreadManager::Get();
-    dbus::Bus* bus = manager->GetSystemBus();
-    dbus::ExportedObject* remote_object = bus->GetExportedObject(
-        dbus::ObjectPath(power_manager::kPowerManagerServicePath));
-    dbus::Signal signal(power_manager::kPowerManagerInterface,
-                        power_manager::kUseNewMonitorConfigSignal);
-    CHECK(signal.raw_message() != NULL);
-    remote_object->SendSignal(&signal);
-
-    // Cache the initial output state.
-    Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
-    CHECK(display != NULL);
-    XGrabServer(display);
-    Window window = DefaultRootWindow(display);
-    XRRScreenResources* screen = XRRGetScreenResources(display, window);
-    CHECK(screen != NULL);
-    bool did_detect_outputs = TryRecacheOutputs(display, screen);
-    CHECK(did_detect_outputs);
-    State current_state = InferCurrentState(display, screen);
-    if (current_state == STATE_INVALID) {
-      // Unknown state.  Transition into the default state.
-      State state = GetDefaultState();
-      UpdateCacheAndXrandrToState(display, screen, window, state);
-    } else {
-      // This is a valid state so just save it to |output_state_|.
-      output_state_ = current_state;
-    }
-    // Find xrandr_event_base_ since we need it to interpret events, later.
-    int error_base_ignored = 0;
-    XRRQueryExtension(display, &xrandr_event_base_, &error_base_ignored);
-    // Relinquish X resources.
-    XRRFreeScreenResources(screen);
-    XUngrabServer(display);
-    CheckIsProjectingAndNotify();
-  }
-}
-
-OutputConfigurator::~OutputConfigurator() {
-}
-
 void OutputConfigurator::UpdateCacheAndXrandrToState(
     Display* display,
     XRRScreenResources* screen,
     Window window,
-    State new_state) {
+    OutputState new_state) {
   // Default rules:
   // - single display = rebuild framebuffer and set to ideal_mode.
   // - multi display = rebuild framebuffer and set to mirror_mode.
 
   // First, calculate the width and height of the framebuffer (we could retain
   // the existing buffer, if it isn't resizing, but that causes an odd display
   // state where the CRTCs are repositioned over the root windows before Chrome
   // can move them).  It is a feature worth considering, though, and wouldn't
   // be difficult to implement (just check the current framebuffer size before
   // changing it).
@@ skipping 127 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Display.XRRGetScreenResources_completed", false);
   PerfTimer histogram_timer;
   XRRScreenResources* screen = XRRGetScreenResources(display, window);
   base::TimeDelta duration = histogram_timer.Elapsed();
   UMA_HISTOGRAM_BOOLEAN("Display.XRRGetScreenResources_completed", true);
   UMA_HISTOGRAM_LONG_TIMES("Display.XRRGetScreenResources_duration", duration);
   CHECK(screen != NULL);
 
   bool did_detect_change = TryRecacheOutputs(display, screen);
   if (did_detect_change) {
-    State state = GetDefaultState();
+    OutputState state = GetDefaultState();
     UpdateCacheAndXrandrToState(display, screen, window, state);
   }
   XRRFreeScreenResources(screen);
   XUngrabServer(display);
   return did_detect_change;
 }
 
-State OutputConfigurator::GetDefaultState() const {
-  State state = STATE_HEADLESS;
+OutputState OutputConfigurator::GetDefaultState() const {
+  OutputState state = STATE_HEADLESS;
   if (-1 != primary_output_index_) {
     if (-1 != secondary_output_index_)
       state = mirror_supported_ ? STATE_DUAL_MIRROR : STATE_DUAL_PRIMARY_ONLY;
     else
       state = STATE_SINGLE;
   }
   return state;
 }
 
-State OutputConfigurator::InferCurrentState(Display* display,
-                                            XRRScreenResources* screen) const {
+OutputState OutputConfigurator::InferCurrentState(
+    Display* display, XRRScreenResources* screen) const {
   // STATE_INVALID will be our default or "unknown" state.
-  State state = STATE_INVALID;
+  OutputState state = STATE_INVALID;
   // First step:  count the number of connected outputs.
   if (secondary_output_index_ == -1) {
     // No secondary display.
     if (primary_output_index_ == -1) {
       // No primary display implies HEADLESS.
       state = STATE_HEADLESS;
     } else {
       // The common case of primary-only.
       // The only sanity check we require in this case is that the current mode
       // of the output's CRTC is the ideal mode we determined for it.
@@ skipping 54 matching lines @@
           // Primary is tiled first.
           state = STATE_DUAL_PRIMARY_ONLY;
         }
       }
     }
   }
 
   return state;
 }
 
-bool OutputConfigurator::CycleDisplayMode(bool extended_desktop_enabled) {
-  VLOG(1) << "CycleDisplayMode";
-  bool did_change = false;
-
-  if (is_running_on_chrome_os_) {
-    // Rules:
-    // - if there are 0 or 1 displays, do nothing and return false.
-    // - use y-coord of CRTCs to determine if we are mirror, primary-first, or
-    // secondary-first.  The cycle order is:
-    //   mirror->primary->secondary->mirror.
-    // Note: If the extended desktop is enabled, the cycle order becomes,
-    // mirror->extended->mirror
-    State new_state = STATE_INVALID;
-    switch (output_state_) {
-      case STATE_DUAL_MIRROR:
-        new_state = STATE_DUAL_PRIMARY_ONLY;
-        break;
-      case STATE_DUAL_PRIMARY_ONLY:
-        if (extended_desktop_enabled) {
-          if (mirror_supported_)
-            new_state = STATE_DUAL_MIRROR;
-          else
-            new_state = STATE_INVALID;
-        } else {
-          new_state = STATE_DUAL_SECONDARY_ONLY;
-        }
-        break;
-      case STATE_DUAL_SECONDARY_ONLY:
-        new_state = mirror_supported_ ?
-            STATE_DUAL_MIRROR :
-            STATE_DUAL_PRIMARY_ONLY;
-        break;
-      default:
-        // Do nothing - we aren't in a mode which we can rotate.
-        break;
-    }
-    if (STATE_INVALID != new_state)
-      did_change = SetDisplayMode(new_state);
-  }
-  return did_change;
-}
-
-bool OutputConfigurator::ScreenPowerSet(bool power_on, bool all_displays) {
-  VLOG(1) << "OutputConfigurator::SetScreensOn " << power_on
-          << " all displays " << all_displays;
-  bool success = false;
-  if (is_running_on_chrome_os_) {
-    Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
-    CHECK(display != NULL);
-    XGrabServer(display);
-    Window window = DefaultRootWindow(display);
-    XRRScreenResources* screen = XRRGetScreenResources(display, window);
-    CHECK(screen != NULL);
-
-    // Set the CRTCs based on whether we want to turn the power on or off and
-    // select the outputs to operate on by name or all_displays.
-    for (int i = 0; i < output_count_; ++i) {
-      if (all_displays || output_cache_[i].is_internal) {
-        const int x = output_cache_[i].x;
-        const int y = output_cache_[i].y;
-        RROutput output = output_cache_[i].output;
-        RRCrtc crtc = output_cache_[i].crtc;
-        RRMode mode = None;
-        if (power_on) {
-          mode = (STATE_DUAL_MIRROR == output_state_) ?
-              output_cache_[i].mirror_mode :
-              output_cache_[i].ideal_mode;
-        }
-
-        VLOG(1) << "SET POWER crtc: " << crtc
-                << ", mode " << mode
-                << ", output " << output
-                << ", x " << x
-                << ", y " << y;
-        // The values we are setting are already from the cache so no update
-        // required.
-        ConfigureCrtc(display,
-                      screen,
-                      crtc,
-                      x,
-                      y,
-                      mode,
-                      output);
-        output_cache_[i].is_powered_on = power_on;
-        success = true;
-      }
-    }
-
-    // Force the DPMS on since the driver doesn't always detect that it should
-    // turn on.
-    if (power_on) {
-      CHECK(DPMSEnable(display));
-      CHECK(DPMSForceLevel(display, DPMSModeOn));
-    }
-
-    XRRFreeScreenResources(screen);
-    XUngrabServer(display);
-  }
-  return success;
-}
-
-bool OutputConfigurator::SetDisplayMode(State new_state) {
-  if (output_state_ == STATE_INVALID ||
-      output_state_ == STATE_HEADLESS ||
-      output_state_ == STATE_SINGLE)
-    return false;
-
-  Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
-  CHECK(display != NULL);
-  XGrabServer(display);
-  Window window = DefaultRootWindow(display);
-  XRRScreenResources* screen = XRRGetScreenResources(display, window);
-  CHECK(screen != NULL);
-
-  UpdateCacheAndXrandrToState(display,
-                              screen,
-                              window,
-                              new_state);
-  XRRFreeScreenResources(screen);
-  XUngrabServer(display);
-  return true;
-}
-
-bool OutputConfigurator::Dispatch(const base::NativeEvent& event) {
-  // Ignore this event if the Xrandr extension isn't supported.
-  if (is_running_on_chrome_os_ &&
-      (event->type - xrandr_event_base_ == RRNotify)) {
-    XEvent* xevent = static_cast<XEvent*>(event);
-    XRRNotifyEvent* notify_event =
-        reinterpret_cast<XRRNotifyEvent*>(xevent);
-    if (notify_event->subtype == RRNotify_OutputChange) {
-      XRROutputChangeNotifyEvent* output_change_event =
-          reinterpret_cast<XRROutputChangeNotifyEvent*>(xevent);
-      if ((output_change_event->connection == RR_Connected) ||
-          (output_change_event->connection == RR_Disconnected)) {
-        RecacheAndUseDefaultState();
-        CheckIsProjectingAndNotify();
-      }
-      // Ignore the case of RR_UnkownConnection.
-    }
-  }
-  return true;
-}
-
 void OutputConfigurator::CheckIsProjectingAndNotify() {
   // Determine if there is an "internal" output and how many outputs are
   // connected.
   bool has_internal_output = false;
   int connected_output_count = 0;
   for (int i = 0; i < output_count_; ++i) {
     if (output_cache_[i].is_connected) {
       connected_output_count += 1;
       has_internal_output |= output_cache_[i].is_internal;
     }
@@ skipping 12 matching lines @@
       power_manager::kSetIsProjectingMethod);
   dbus::MessageWriter writer(&method_call);
   writer.AppendBool(is_projecting);
   power_manager_proxy->CallMethod(
       &method_call,
       dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
       dbus::ObjectProxy::EmptyResponseCallback());
 }
 
 }  // namespace chromeos