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;

[dnicoara, 2014/04/04 18:28:59]

Daniel, are you thinking to rename typedefs such as this one as well?

If yes, I'll just do it part of this CL since they get used in all these files
that I'm already modifying.

I'd also like to change all the enums in display_constants.h from OUTPUT_* to
DISPLAY_* if that's OK.

[Daniel Erat, 2014/04/04 21:04:55]

yeah, i think it makes sense to just drop the "output" terminology entirely.

[dnicoara, 2014/04/07 17:10:39]

Actually, I started the other renames and there are quite a few changes. I'll
split them in a few other CLs for an easier review process.

   static const OutputProtectionClientId kInvalidClientId = 0;
 
   struct CoordinateTransformation {
     // Initialized to the identity transformation.
     CoordinateTransformation();
 
     float x_scale;
     float x_offset;
     float y_scale;
     float y_offset;
@@ skipping 75 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_