Renamed OutputConfigurator to DisplayConfigurator

ui/display/chromeos/display_configurator.h

 // 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.
 
-#ifndef UI_DISPLAY_CHROMEOS_OUTPUT_CONFIGURATOR_H_
-#define UI_DISPLAY_CHROMEOS_OUTPUT_CONFIGURATOR_H_
+#ifndef UI_DISPLAY_CHROMEOS_DISPLAY_CONFIGURATOR_H_
+#define UI_DISPLAY_CHROMEOS_DISPLAY_CONFIGURATOR_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/event_types.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/timer/timer.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/display/chromeos/native_display_observer.h"
 #include "ui/display/display_constants.h"
 #include "ui/display/display_export.h"
 
 namespace gfx {
 class Point;
 class Size;
 }
 
 namespace ui {
 class DisplayMode;
 class DisplaySnapshot;
 class NativeDisplayDelegate;
 
 // This class interacts directly with the system display configurator.
-class DISPLAY_EXPORT OutputConfigurator : public NativeDisplayObserver {
+class DISPLAY_EXPORT DisplayConfigurator : public NativeDisplayObserver {
  public:
   typedef uint64_t OutputProtectionClientId;
   static const OutputProtectionClientId kInvalidClientId = 0;
 
   struct CoordinateTransformation {
     // Initialized to the identity transformation.
     CoordinateTransformation();
 
     float x_scale;
     float x_offset;
@@ skipping 77 matching lines @@
     // |ctm| contains the desired transformation parameters.  The offsets
     // in it should be normalized so that 1 corresponds to the X or Y axis
     // size for the corresponding offset.
     virtual void ConfigureCTM(int touch_device_id,
                               const CoordinateTransformation& ctm) = 0;
   };
 
   // Helper class used by tests.
   class TestApi {
    public:
-    TestApi(OutputConfigurator* configurator) : configurator_(configurator) {}
+    TestApi(DisplayConfigurator* configurator) : configurator_(configurator) {}
     ~TestApi() {}
 
     // If |configure_timer_| is started, stops the timer, runs
     // ConfigureOutputs(), and returns true; returns false otherwise.
     bool TriggerConfigureTimeout();
 
    private:
-    OutputConfigurator* configurator_;  // not owned
+    DisplayConfigurator* configurator_;  // not owned
 
     DISALLOW_COPY_AND_ASSIGN(TestApi);
   };
 
   // Flags that can be passed to SetDisplayPower().
   static const int kSetDisplayPowerNoFlags = 0;
   // Configure displays even if the passed-in state matches |power_state_|.
   static const int kSetDisplayPowerForceProbe = 1 << 0;
   // Do not change the state if multiple displays are connected or if the
   // only connected display is external.
   static const int kSetDisplayPowerOnlyIfSingleInternalDisplay = 1 << 1;
 
   // Gap between screens so cursor at bottom of active display doesn't
   // partially appear on top of inactive display. Higher numbers guard
   // against larger cursors, but also waste more memory.
   // For simplicity, this is hard-coded to avoid the complexity of always
   // determining the DPI of the screen and rationalizing which screen we
   // need to use for the DPI calculation.
   // See crbug.com/130188 for initial discussion.
   static const int kVerticalGap = 60;
 
   // Returns the mode within |output| that matches the given size with highest
   // refresh rate. Returns None if no matching output was found.
   static const DisplayMode* FindDisplayModeMatchingSize(
       const DisplaySnapshot& output,
       const gfx::Size& size);
 
-  OutputConfigurator();
-  virtual ~OutputConfigurator();
+  DisplayConfigurator();
+  virtual ~DisplayConfigurator();
 
   OutputState output_state() const { return output_state_; }
   chromeos::DisplayPowerState power_state() const { return power_state_; }
   const std::vector<DisplayState>& cached_outputs() const {
     return cached_outputs_;
   }
 
   void set_state_controller(StateController* controller) {
     state_controller_ = controller;
   }
@@ skipping 11 matching lines @@
 
   // Sets the initial value of |power_state_|.  Must be called before Start().
   void SetInitialDisplayPower(chromeos::DisplayPowerState power_state);
 
   // Initialization, must be called right after constructor.
   // |is_panel_fitting_enabled| indicates hardware panel fitting support.
   void Init(bool is_panel_fitting_enabled);
 
   // Does initial configuration of displays during startup.
   // If |background_color_argb| is non zero and there are multiple displays,
-  // OutputConfigurator sets the background color of X's RootWindow to this
+  // DisplayConfigurator sets the background color of X's RootWindow to this
   // color.
   void ForceInitialConfigure(uint32_t background_color_argb);
 
   // Stop handling display configuration events/requests.
   void PrepareForExit();
 
   // Called when powerd notifies us that some set of displays should be turned
   // on or off.  This requires enabling or disabling the CRTC associated with
   // the display(s) in question so that the low power state is engaged.
   // |flags| contains bitwise-or-ed kSetDisplayPower* values.
@@ skipping 47 matching lines @@
   bool EnableOutputProtection(OutputProtectionClientId client_id,
                               int64_t display_id,
                               uint32_t desired_protection_mask);
 
   // Checks the available color profiles for |display_id| and fills the result
   // into |profiles|.
   std::vector<ui::ColorCalibrationProfile> GetAvailableColorCalibrationProfiles(
       int64_t display_id);
 
   // Updates the color calibration to |new_profile|.
-  bool SetColorCalibrationProfile(
-      int64_t display_id,
-      ui::ColorCalibrationProfile new_profile);
+  bool SetColorCalibrationProfile(int64_t display_id,
+                                  ui::ColorCalibrationProfile new_profile);
 
  private:
   // Mapping a display_id to a protection request bitmask.
   typedef std::map<int64_t, uint32_t> DisplayProtections;
   // Mapping a client to its protection request.
   typedef std::map<OutputProtectionClientId, DisplayProtections>
       ProtectionRequests;
 
   // Updates |cached_outputs_| to contain currently-connected outputs. Calls
   // |delegate_->GetOutputs()| and then does additional work, like finding the
@@ skipping 95 matching lines @@
   chromeos::DisplayPowerState power_state_;
 
   // Most-recently-used output configuration. Note that the actual
   // configuration changes asynchronously.
   DisplayStateList cached_outputs_;
 
   ObserverList<Observer> observers_;
 
   // The timer to delay configuring outputs. See also the comments in
   // Dispatch().
-  scoped_ptr<base::OneShotTimer<OutputConfigurator> > configure_timer_;
+  scoped_ptr<base::OneShotTimer<DisplayConfigurator> > configure_timer_;
 
   // Id for next output protection client.
   OutputProtectionClientId next_output_protection_client_id_;
 
   // Output protection requests of each client.
   ProtectionRequests client_protection_requests_;
 
-  DISALLOW_COPY_AND_ASSIGN(OutputConfigurator);
+  DISALLOW_COPY_AND_ASSIGN(DisplayConfigurator);
 };
 
 }  // namespace ui
 
-#endif  // UI_DISPLAY_CHROMEOS_OUTPUT_CONFIGURATOR_H_
+#endif  // UI_DISPLAY_CHROMEOS_DISPLAY_CONFIGURATOR_H_