Move chromeos/display/* to ui/display/chromeos

ui/display/chromeos/x11/native_display_delegate_x11.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 "chromeos/display/native_display_delegate_x11.h"
+#include "ui/display/chromeos/x11/native_display_delegate_x11.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/Xrandr.h>
 #include <X11/extensions/XInput2.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_pump_x11.h"
 #include "base/x11/edid_parser_x11.h"
 #include "base/x11/x11_error_tracker.h"
-#include "chromeos/display/native_display_event_dispatcher_x11.h"
-#include "chromeos/display/native_display_observer.h"
-#include "chromeos/display/output_util.h"
+#include "ui/display/chromeos/native_display_observer.h"
+#include "ui/display/chromeos/x11/display_util.h"
+#include "ui/display/chromeos/x11/native_display_event_dispatcher_x11.h"
 
-namespace chromeos {
+namespace ui {
 
 namespace {
 
 // DPI measurements.
 const float kMmInInch = 25.4;
 const float kDpi96 = 96.0;
 const float kPixelsToMmScale = kMmInInch / kDpi96;
 
-// Prefixes of output name
-const char kOutputName_VGA[] = "VGA";
-const char kOutputName_HDMI[] = "HDMI";
-const char kOutputName_DVI[] = "DVI";
-const char kOutputName_DisplayPort[] = "DP";
-
 const char kContentProtectionAtomName[] = "Content Protection";
 const char kProtectionUndesiredAtomName[] = "Undesired";
 const char kProtectionDesiredAtomName[] = "Desired";
 const char kProtectionEnabledAtomName[] = "Enabled";
 
-bool IsInternalOutput(const XRROutputInfo* output_info) {
-  return IsInternalOutputName(std::string(output_info->name));
-}
-
 RRMode GetOutputNativeMode(const XRROutputInfo* output_info) {
   return output_info->nmode > 0 ? output_info->modes[0] : None;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeDisplayDelegateX11::HelperDelegateX11
 
 class NativeDisplayDelegateX11::HelperDelegateX11
     : public NativeDisplayDelegateX11::HelperDelegate {
  public:
-  HelperDelegateX11(NativeDisplayDelegateX11* delegate)
-      : delegate_(delegate) {}
+  HelperDelegateX11(NativeDisplayDelegateX11* delegate) : delegate_(delegate) {}
   virtual ~HelperDelegateX11() {}
 
   // NativeDisplayDelegateX11::HelperDelegate overrides:
-  virtual void UpdateXRandRConfiguration(
-      const base::NativeEvent& event) OVERRIDE {
+  virtual void UpdateXRandRConfiguration(const base::NativeEvent& event)
+      OVERRIDE {
     XRRUpdateConfiguration(event);
   }
   virtual const std::vector<OutputConfigurator::OutputSnapshot>&
-      GetCachedOutputs() const OVERRIDE {
+  GetCachedOutputs() const OVERRIDE {
     return delegate_->cached_outputs_;
   }
   virtual void NotifyDisplayObservers() OVERRIDE {
-    FOR_EACH_OBSERVER(NativeDisplayObserver,
-                      delegate_->observers_,
-                      OnConfigurationChanged());
+    FOR_EACH_OBSERVER(
+        NativeDisplayObserver, delegate_->observers_, OnConfigurationChanged());
   }
 
  private:
   NativeDisplayDelegateX11* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(HelperDelegateX11);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeDisplayDelegateX11::MessagePumpObserverX11
 
 class NativeDisplayDelegateX11::MessagePumpObserverX11
     : public base::MessagePumpObserver {
  public:
   MessagePumpObserverX11(HelperDelegate* delegate);
   virtual ~MessagePumpObserverX11();
 
   // base::MessagePumpObserver overrides:
-  virtual base::EventStatus WillProcessEvent(
-      const base::NativeEvent& event) OVERRIDE;
+  virtual base::EventStatus WillProcessEvent(const base::NativeEvent& event)
+      OVERRIDE;
   virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE;
 
  private:
   HelperDelegate* delegate_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(MessagePumpObserverX11);
 };
 
 NativeDisplayDelegateX11::MessagePumpObserverX11::MessagePumpObserverX11(
-    HelperDelegate* delegate) : delegate_(delegate) {}
+    HelperDelegate* delegate)
+    : delegate_(delegate) {}
 
 NativeDisplayDelegateX11::MessagePumpObserverX11::~MessagePumpObserverX11() {}
 
 base::EventStatus
 NativeDisplayDelegateX11::MessagePumpObserverX11::WillProcessEvent(
     const base::NativeEvent& event) {
   // XI_HierarchyChanged events are special. There is no window associated with
   // these events. So process them directly from here.
   if (event->type == GenericEvent &&
       event->xgeneric.evtype == XI_HierarchyChanged) {
     VLOG(1) << "Received XI_HierarchyChanged event";
     // Defer configuring outputs to not stall event processing.
     // This also takes care of same event being received twice.
     delegate_->NotifyDisplayObservers();
   }
 
   return base::EVENT_CONTINUE;
 }
 
 void NativeDisplayDelegateX11::MessagePumpObserverX11::DidProcessEvent(
-    const base::NativeEvent& event) {
-}
+    const base::NativeEvent& event) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeDisplayDelegateX11 implementation:
 
 NativeDisplayDelegateX11::NativeDisplayDelegateX11()
     : display_(base::MessagePumpX11::GetDefaultXDisplay()),
       window_(DefaultRootWindow(display_)),
       screen_(NULL) {}
 
 NativeDisplayDelegateX11::~NativeDisplayDelegateX11() {
   base::MessagePumpX11::Current()->RemoveDispatcherForRootWindow(
       message_pump_dispatcher_.get());
   base::MessagePumpX11::Current()->RemoveObserver(message_pump_observer_.get());
 }
 
 void NativeDisplayDelegateX11::Initialize() {
   int error_base_ignored = 0;
   int xrandr_event_base = 0;
   XRRQueryExtension(display_, &xrandr_event_base, &error_base_ignored);
 
   helper_delegate_.reset(new HelperDelegateX11(this));
   message_pump_dispatcher_.reset(new NativeDisplayEventDispatcherX11(
       helper_delegate_.get(), xrandr_event_base));
-  message_pump_observer_.reset(new MessagePumpObserverX11(
-      helper_delegate_.get()));
+  message_pump_observer_.reset(
+      new MessagePumpObserverX11(helper_delegate_.get()));
 
   base::MessagePumpX11::Current()->AddDispatcherForRootWindow(
       message_pump_dispatcher_.get());
   // We can't do this with a root window listener because XI_HierarchyChanged
   // messages don't have a target window.
   base::MessagePumpX11::Current()->AddObserver(message_pump_observer_.get());
 }
 
 void NativeDisplayDelegateX11::GrabServer() {
   CHECK(!screen_) << "Server already grabbed";
@@ skipping 53 matching lines @@
               << " current_mode=" << output.current_mode;
       cached_outputs_.push_back(output);
     }
     XRRFreeOutputInfo(output_info);
   }
 
   return cached_outputs_;
 }
 
 void NativeDisplayDelegateX11::AddMode(
-    const OutputConfigurator::OutputSnapshot& output, RRMode mode) {
+    const OutputConfigurator::OutputSnapshot& output,
+    RRMode mode) {
   CHECK(screen_) << "Server not grabbed";
   VLOG(1) << "AddOutputMode: output=" << output.output << " mode=" << mode;
   XRRAddOutputMode(display_, output.output, mode);
 }
 
 bool NativeDisplayDelegateX11::Configure(
     const OutputConfigurator::OutputSnapshot& output,
     RRMode mode,
     int x,
     int y) {
   return ConfigureCrtc(output.crtc, mode, output.output, x, y);
 }
 
-bool NativeDisplayDelegateX11::ConfigureCrtc(
-    RRCrtc crtc,
-    RRMode mode,
-    RROutput output,
-    int x,
-    int y) {
+bool NativeDisplayDelegateX11::ConfigureCrtc(RRCrtc crtc,
+                                             RRMode mode,
+                                             RROutput output,
+                                             int x,
+                                             int y) {
   CHECK(screen_) << "Server not grabbed";
   VLOG(1) << "ConfigureCrtc: crtc=" << crtc << " mode=" << mode
           << " output=" << output << " x=" << x << " y=" << y;
   // Xrandr.h is full of lies. XRRSetCrtcConfig() is defined as returning a
   // Status, which is typically 0 for failure and 1 for success. In
   // actuality it returns a RRCONFIGSTATUS, which uses 0 for success.
   return XRRSetCrtcConfig(display_,
                           screen_,
                           crtc,
                           CurrentTime,
@@ skipping 55 matching lines @@
     RROutput id,
     XRROutputInfo* info,
     RRCrtc* last_used_crtc,
     int index) {
   OutputConfigurator::OutputSnapshot output;
   output.output = id;
   output.width_mm = info->mm_width;
   output.height_mm = info->mm_height;
   output.has_display_id = base::GetDisplayId(id, index, &output.display_id);
   output.index = index;
-  bool is_internal = IsInternalOutput(info);
+  output.type = GetOutputTypeFromName(info->name);
+
+  if (output.type == OUTPUT_TYPE_UNKNOWN)
+    LOG(ERROR) << "Unknown link type: " << info->name;
 
   // Use the index as a valid display ID even if the internal
   // display doesn't have valid EDID because the index
   // will never change.
-  if (!output.has_display_id && is_internal)
+  if (!output.has_display_id && output.type == OUTPUT_TYPE_INTERNAL)
     output.has_display_id = true;
 
   if (info->crtc) {
     XRRCrtcInfo* crtc_info = XRRGetCrtcInfo(display_, screen_, info->crtc);
     output.current_mode = crtc_info->mode;
     output.x = crtc_info->x;
     output.y = crtc_info->y;
     XRRFreeCrtcInfo(crtc_info);
   }
 
@@ skipping 12 matching lines @@
 
   for (int i = 0; i < info->nmode; ++i) {
     const RRMode mode = info->modes[i];
     OutputConfigurator::ModeInfo mode_info;
     if (InitModeInfo(mode, &mode_info))
       output.mode_infos.insert(std::make_pair(mode, mode_info));
     else
       LOG(WARNING) << "Unable to find XRRModeInfo for mode " << mode;
   }
 
-  std::string name(info->name);
-  if (is_internal) {
-    output.type = ui::OUTPUT_TYPE_INTERNAL;
-  } else if (name.find(kOutputName_VGA) == 0) {
-    output.type = ui::OUTPUT_TYPE_VGA;
-  } else if (name.find(kOutputName_HDMI) == 0) {
-    output.type = ui::OUTPUT_TYPE_HDMI;
-  } else if (name.find(kOutputName_DVI) == 0) {
-    output.type = ui::OUTPUT_TYPE_DVI;
-  } else if (name.find(kOutputName_DisplayPort) == 0) {
-    output.type = ui::OUTPUT_TYPE_DISPLAYPORT;
-  } else {
-    LOG(ERROR) << "Unknown link type: " << name;
-    output.type = ui::OUTPUT_TYPE_UNKNOWN;
-  }
-
   return output;
 }
 
 bool NativeDisplayDelegateX11::GetHDCPState(
-    const OutputConfigurator::OutputSnapshot& output, ui::HDCPState* state) {
+    const OutputConfigurator::OutputSnapshot& output,
+    HDCPState* state) {
   unsigned char* values = NULL;
   int actual_format = 0;
   unsigned long nitems = 0;
   unsigned long bytes_after = 0;
   Atom actual_type = None;
   int success = 0;
   // TODO(kcwu): Use X11AtomCache to save round trip time of XInternAtom.
   Atom prop = XInternAtom(display_, kContentProtectionAtomName, False);
 
   bool ok = true;
@@ skipping 13 matching lines @@
                                  &bytes_after,
                                  &values);
   if (actual_type == None) {
     LOG(ERROR) << "Property '" << kContentProtectionAtomName
                << "' does not exist";
     ok = false;
   } else if (success == Success && actual_type == XA_ATOM &&
              actual_format == 32 && nitems == 1) {
     Atom value = reinterpret_cast<Atom*>(values)[0];
     if (value == XInternAtom(display_, kProtectionUndesiredAtomName, False)) {
-      *state = ui::HDCP_STATE_UNDESIRED;
+      *state = HDCP_STATE_UNDESIRED;
     } else if (value ==
                XInternAtom(display_, kProtectionDesiredAtomName, False)) {
-      *state = ui::HDCP_STATE_DESIRED;
+      *state = HDCP_STATE_DESIRED;
     } else if (value ==
                XInternAtom(display_, kProtectionEnabledAtomName, False)) {
-      *state = ui::HDCP_STATE_ENABLED;
+      *state = HDCP_STATE_ENABLED;
     } else {
       LOG(ERROR) << "Unknown " << kContentProtectionAtomName
                  << " value: " << value;
       ok = false;
     }
   } else {
     LOG(ERROR) << "XRRGetOutputProperty failed";
     ok = false;
   }
   if (values)
     XFree(values);
 
   VLOG(3) << "HDCP state: " << ok << "," << *state;
   return ok;
 }
 
 bool NativeDisplayDelegateX11::SetHDCPState(
-    const OutputConfigurator::OutputSnapshot& output, ui::HDCPState state) {
+    const OutputConfigurator::OutputSnapshot& output,
+    HDCPState state) {
   Atom name = XInternAtom(display_, kContentProtectionAtomName, False);
   Atom value = None;
   switch (state) {
-    case ui::HDCP_STATE_UNDESIRED:
+    case HDCP_STATE_UNDESIRED:
       value = XInternAtom(display_, kProtectionUndesiredAtomName, False);
       break;
-    case ui::HDCP_STATE_DESIRED:
+    case HDCP_STATE_DESIRED:
       value = XInternAtom(display_, kProtectionDesiredAtomName, False);
       break;
     default:
       NOTREACHED() << "Invalid HDCP state: " << state;
       return false;
   }
   base::X11ErrorTracker err_tracker;
   unsigned char* data = reinterpret_cast<unsigned char*>(&value);
   XRRChangeOutputProperty(
       display_, output.output, name, XA_ATOM, 32, PropModeReplace, data, 1);
@@ skipping 105 matching lines @@
 }
 
 void NativeDisplayDelegateX11::AddObserver(NativeDisplayObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void NativeDisplayDelegateX11::RemoveObserver(NativeDisplayObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-}  // namespace chromeos
+}  // namespace ui