Remove unnecessary display:: namespaces.

ui/display/manager/managed_display_info.h

 // Copyright (c) 2013 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_MANAGER_MANAGED_DISPLAY_INFO_H_
 #define UI_DISPLAY_MANAGER_MANAGED_DISPLAY_INFO_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "ui/display/display.h"
 #include "ui/display/display_export.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace display {
 
 // A class that represents the display's mode info.
 class DISPLAY_EXPORT ManagedDisplayMode
     : public base::RefCounted<ManagedDisplayMode> {
  public:
   ManagedDisplayMode();
 
-  ManagedDisplayMode(const gfx::Size& size);
+  explicit ManagedDisplayMode(const gfx::Size& size);
 
   ManagedDisplayMode(const gfx::Size& size,
                      float refresh_rate,
                      bool is_interlaced,
                      bool native);
 
   ManagedDisplayMode(const gfx::Size& size,
                      float refresh_rate,
                      bool is_interlaced,
                      bool native,
@@ skipping 26 matching lines @@
   float refresh_rate_;         // Refresh rate of the display, in Hz.
   bool is_interlaced_;         // True if mode is interlaced.
   bool native_;                // True if mode is native mode of the display.
   bool is_default_ = false;    // True if mode is one with default UI scale.
   float ui_scale_;             // The UI scale factor of the mode.
   float device_scale_factor_;  // The device scale factor of the mode.
 
   DISALLOW_COPY_AND_ASSIGN(ManagedDisplayMode);
 };
 
-// ManagedDisplayInfo contains metadata for each display. This is used to
-// create |display::Display| as well as to maintain extra infomation
-// to manage displays in ash environment.
-// This class is intentionally made copiable.
+// ManagedDisplayInfo contains metadata for each display. This is used to create
+// |Display| as well as to maintain extra infomation to manage displays in ash
+// environment. This class is intentionally made copiable.
 class DISPLAY_EXPORT ManagedDisplayInfo {
  public:
   using ManagedDisplayModeList = std::vector<scoped_refptr<ManagedDisplayMode>>;
 
   // Creates a ManagedDisplayInfo from string spec. 100+200-1440x800 creates
   // display
   // whose size is 1440x800 at the location (100, 200) in host coordinates.
   // The format is
   //
   // [origin-]widthxheight[*device_scale_factor][#resolutions list]
@@ skipping 49 matching lines @@
   const std::string& name() const { return name_; }
 
   // The path to the display device in the sysfs filesystem.
   void set_sys_path(const base::FilePath& sys_path) { sys_path_ = sys_path; }
   const base::FilePath& sys_path() const { return sys_path_; }
 
   // True if the display EDID has the overscan flag. This does not create the
   // actual overscan automatically, but used in the message.
   bool has_overscan() const { return has_overscan_; }
 
-  void set_touch_support(display::Display::TouchSupport support) {
+  void set_touch_support(Display::TouchSupport support) {
     touch_support_ = support;
   }
-  display::Display::TouchSupport touch_support() const {
-    return touch_support_;
-  }
+  Display::TouchSupport touch_support() const { return touch_support_; }
 
   // Associate the input device with identifier |id| with this display.
   void AddInputDevice(int id);
 
   // Clear the list of input devices associated with this display.
   void ClearInputDevices();
 
   // The input device ids that are associated with this display.
   std::vector<int> input_devices() const { return input_devices_; }
 
@@ skipping 19 matching lines @@
   }
 
   // Sets/gets configured ui scale. This can be different from the ui
   // scale actually used when the scale is 2.0 and DSF is 2.0.
   // (the effective ui scale is 1.0 in this case).
   float configured_ui_scale() const { return configured_ui_scale_; }
   void set_configured_ui_scale(float scale) { configured_ui_scale_ = scale; }
 
   // Sets the rotation for the given |source|. Setting a new rotation will also
   // have it become the active rotation.
-  void SetRotation(display::Display::Rotation rotation,
-                   display::Display::RotationSource source);
+  void SetRotation(Display::Rotation rotation, Display::RotationSource source);
 
   // Returns the currently active rotation for this display.
-  display::Display::Rotation GetActiveRotation() const;
+  Display::Rotation GetActiveRotation() const;
 
   // Returns the source which set the active rotation for this display.
-  display::Display::RotationSource active_rotation_source() const {
+  Display::RotationSource active_rotation_source() const {
     return active_rotation_source_;
   }
 
   // Returns the rotation set by a given |source|.
-  display::Display::Rotation GetRotation(
-      display::Display::RotationSource source) const;
+  Display::Rotation GetRotation(Display::RotationSource source) const;
 
   // Returns the ui scale and device scale factor actually used to create
   // display that chrome sees. This can be different from one obtained
   // from dispaly or one specified by a user in following situation.
   // 1) DSF is 2.0f and UI scale is 2.0f. (Returns 1.0f and 1.0f respectiely)
   // 2) A user specified 0.8x on the device that has 1.25 DSF. 1.25 DSF device
   //    uses 1.0f DFS unless 0.8x UI scaling is specified.
   float GetEffectiveDeviceScaleFactor() const;
 
   // Returns the ui scale used for the device scale factor. This
@@ skipping 78 matching lines @@
 
  private:
   // Returns true if this display should use DSF=1.25 for UI scaling; i.e.
   // SetUse125DSFForUIScaling(true) is called and this is the internal display.
   bool Use125DSFForUIScaling() const;
 
   int64_t id_;
   std::string name_;
   base::FilePath sys_path_;
   bool has_overscan_;
-  std::map<display::Display::RotationSource, display::Display::Rotation>
-      rotations_;
-  display::Display::RotationSource active_rotation_source_;
-  display::Display::TouchSupport touch_support_;
+  std::map<Display::RotationSource, Display::Rotation> rotations_;
+  Display::RotationSource active_rotation_source_;
+  Display::TouchSupport touch_support_;
 
   // The set of input devices associated with this display.
   std::vector<int> input_devices_;
 
   // This specifies the device's pixel density. (For example, a
   // display whose DPI is higher than the threshold is considered to have
   // device_scale_factor = 2.0 on Chrome OS).  This is used by the
   // grapics layer to choose and draw appropriate images and scale
   // layers properly.
   float device_scale_factor_;
@@ skipping 42 matching lines @@
   // If you add a new member, you need to update Copy().
 };
 
 // Resets the synthesized display id for testing. This
 // is necessary to avoid overflowing the output index.
 void DISPLAY_EXPORT ResetDisplayIdForTest();
 
 }  // namespace display
 
 #endif  //  UI_DISPLAY_MANAGER_MANAGED_DISPLAY_INFO_H_