Make DisplayInfoProvider an interface

chrome/browser/extensions/display_info_provider_chromeos.cc

 // Copyright 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.
 
-#include "chrome/browser/extensions/api/system_display/display_info_provider.h"
+#include "chrome/browser/extensions/display_info_provider_chromeos.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
+#include "chrome/common/extensions/api/system_display.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 
 using ash::DisplayManager;
 
 namespace extensions {
 
 using api::system_display::Bounds;
 using api::system_display::DisplayUnitInfo;
@@ skipping 36 matching lines @@
 bool PointIsOverRadiusVector(const gfx::Point& point,
                              const gfx::Point& vector) {
   // |point| is left of |vector| if its radius vector's scalar product with a
   // vector orthogonal (and facing the positive side) to |vector| is positive.
   //
   // An orthogonal vector of (a, b) is (b, -a), as the scalar product of these
   // two is 0.
   // So, (x, y) is over (a, b) if x * b + y * (-a) >= 0, which is equivalent to
   // x * b >= y * a.
   return static_cast<int64>(point.x()) * static_cast<int64>(vector.y()) >=
-      static_cast<int64>(point.y()) * static_cast<int64>(vector.x());
+         static_cast<int64>(point.y()) * static_cast<int64>(vector.x());
 }
 
 // Created ash::DisplayLayout value for |rectangle| compared to the |reference|
 // rectangle.
 // The layout consists of two values:
 //   - position: Whether the rectangle is positioned left, right, over or under
 //     the reference.
 //   - offset: The rectangle's offset from the reference origin along the axis
 //     opposite the position direction (if the rectangle is left or right along
 //     y-axis, otherwise along x-axis).
@@ skipping 36 matching lines @@
   // Note that the coordinate system is scaled by 2.
   center.Offset(0, -2 * reference.height());
   // Choose the vector orientation so the points on the diagonal are considered
   // to be left.
   gfx::Point up_diag(-2 * reference.width(), 2 * reference.height());
 
   bool is_bottom_right = PointIsOverRadiusVector(center, up_diag);
 
   ash::DisplayLayout::Position position;
   if (is_top_right) {
-    position = is_bottom_right ? ash::DisplayLayout::RIGHT :
-                                 ash::DisplayLayout::TOP;
+    position =
+        is_bottom_right ? ash::DisplayLayout::RIGHT : ash::DisplayLayout::TOP;
   } else {
     position =
         is_bottom_right ? ash::DisplayLayout::BOTTOM : ash::DisplayLayout::LEFT;
   }
 
   // If the rectangle with the calculated position would not have common side
   // with the reference, try to position it so it shares another edge with the
   // reference.
   if (is_top_right == is_bottom_right) {
     if (rectangle.y() > reference.y() + reference.height()) {
@@ skipping 20 matching lines @@
     return ash::DisplayLayout::FromInts(position, rectangle.x());
   }
 }
 
 // Updates the display layout for the target display in reference to the primary
 // display.
 void UpdateDisplayLayout(const gfx::Rect& primary_display_bounds,
                          int primary_display_id,
                          const gfx::Rect& target_display_bounds,
                          int target_display_id) {
-  ash::DisplayLayout layout = GetLayoutForRectangles(primary_display_bounds,
-                                                     target_display_bounds);
-  ash::Shell::GetInstance()->display_manager()->
-      SetLayoutForCurrentDisplays(layout);
+  ash::DisplayLayout layout =
+      GetLayoutForRectangles(primary_display_bounds, target_display_bounds);
+  ash::Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
+      layout);
 }
 
 // Validates that parameters passed to the SetInfo function are valid for the
 // desired display and the current display manager state.
 // Returns whether the parameters are valid. On failure |error| is set to the
 // error message.
 bool ValidateParamsForDisplay(const DisplayProperties& info,
                               const gfx::Display& display,
                               DisplayManager* display_manager,
                               int64 primary_display_id,
@@ skipping 13 matching lines @@
     }
 
     if (*info.mirroring_source_id == base::Int64ToString(display.id())) {
       *error = "Not allowed to mirror self.";
       return false;
     }
   }
 
   // If mirroring source parameter is specified, no other parameter should be
   // set as when the mirroring is applied the display list could change.
-  if (info.mirroring_source_id && (info.is_primary || info.bounds_origin_x ||
-      info.bounds_origin_y || info.rotation || info.overscan)) {
+  if (info.mirroring_source_id &&
+      (info.is_primary || info.bounds_origin_x || info.bounds_origin_y ||
+       info.rotation || info.overscan)) {
     *error = "No other parameter should be set alongside mirroringSourceId.";
     return false;
   }
 
   // The bounds cannot be changed for the primary display and should be inside
   // a reasonable bounds. Note that the display is considered primary if the
   // info has 'isPrimary' parameter set, as this will be applied before bounds
   // origin changes.
   if (info.bounds_origin_x || info.bounds_origin_y) {
     if (is_primary) {
       *error = "Bounds origin not allowed for the primary display.";
       return false;
     }
-    if (info.bounds_origin_x &&
-        (*info.bounds_origin_x > kMaxBoundsOrigin ||
-         *info.bounds_origin_x < -kMaxBoundsOrigin)) {
+    if (info.bounds_origin_x && (*info.bounds_origin_x > kMaxBoundsOrigin ||
+                                 *info.bounds_origin_x < -kMaxBoundsOrigin)) {
       *error = "Bounds origin x out of bounds.";
       return false;
     }
-    if (info.bounds_origin_y &&
-        (*info.bounds_origin_y > kMaxBoundsOrigin ||
-         *info.bounds_origin_y < -kMaxBoundsOrigin)) {
+    if (info.bounds_origin_y && (*info.bounds_origin_y > kMaxBoundsOrigin ||
+                                 *info.bounds_origin_y < -kMaxBoundsOrigin)) {
       *error = "Bounds origin y out of bounds.";
       return false;
     }
   }
 
   // Verify the rotation value is valid.
   if (info.rotation && !IsValidRotationValue(*info.rotation)) {
     *error = "Invalid rotation.";
     return false;
   }
@@ skipping 34 matching lines @@
 gfx::Display GetTargetDisplay(const std::string& display_id_str,
                               DisplayManager* manager) {
   int64 display_id;
   if (!base::StringToInt64(display_id_str, &display_id)) {
     // This should return invalid display.
     return gfx::Display();
   }
   return manager->GetDisplayForId(display_id);
 }
 
-// Updates the display with |display_id_str| id according to |info|. Returns
-// whether the display was successfully updated. On failure, no display
-// parameters should be changed, and |error| should be set to the error string.
-bool SetInfoImpl(const std::string& display_id_str,
-                 const DisplayProperties& info,
-                 std::string* error) {
+}  // namespace
+
+DisplayInfoProviderChromeOS::DisplayInfoProviderChromeOS() {
+}
+
+DisplayInfoProviderChromeOS::~DisplayInfoProviderChromeOS() {
+}
+
+bool DisplayInfoProviderChromeOS::SetInfo(const std::string& display_id_str,
+                                          const DisplayProperties& info,
+                                          std::string* error) {
   DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   DCHECK(display_manager);
   ash::DisplayController* display_controller =
       ash::Shell::GetInstance()->display_controller();
   DCHECK(display_controller);
 
   const gfx::Display target = GetTargetDisplay(display_id_str, display_manager);
 
   if (target.id() == gfx::Display::kInvalidDisplayID) {
     *error = "Display not found.";
     return false;
   }
 
   int64 display_id = target.id();
   // TODO(scottmg): Native is wrong http://crbug.com/133312
   const gfx::Display& primary =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
 
-  if (!ValidateParamsForDisplay(info, target, display_manager, primary.id(),
-                                error)) {
+  if (!ValidateParamsForDisplay(
+          info, target, display_manager, primary.id(), error)) {
     return false;
   }
 
   // Process 'isPrimary' parameter.
   if (info.is_primary && *info.is_primary && target.id() != primary.id())
     display_controller->SetPrimaryDisplayId(display_id);
 
   // Process 'mirroringSourceId' parameter.
   if (info.mirroring_source_id &&
       info.mirroring_source_id->empty() == display_manager->IsMirrored()) {
     display_controller->ToggleMirrorMode();
   }
 
   // Process 'overscan' parameter.
   if (info.overscan) {
-    display_manager->SetOverscanInsets(
-        display_id,
-        gfx::Insets(info.overscan->top, info.overscan->left,
-                    info.overscan->bottom, info.overscan->right));
+    display_manager->SetOverscanInsets(display_id,
+                                       gfx::Insets(info.overscan->top,
+                                                   info.overscan->left,
+                                                   info.overscan->bottom,
+                                                   info.overscan->right));
   }
 
   // Process 'rotation' parameter.
   if (info.rotation) {
     display_manager->SetDisplayRotation(display_id,
                                         DegreesToRotation(*info.rotation));
   }
 
   // Process new display origin parameters.
   gfx::Point new_bounds_origin = target.bounds().origin();
   if (info.bounds_origin_x)
     new_bounds_origin.set_x(*info.bounds_origin_x);
   if (info.bounds_origin_y)
     new_bounds_origin.set_y(*info.bounds_origin_y);
 
   if (new_bounds_origin != target.bounds().origin()) {
     gfx::Rect target_bounds = target.bounds();
     target_bounds.Offset(new_bounds_origin.x() - target.bounds().x(),
                          new_bounds_origin.y() - target.bounds().y());
-    UpdateDisplayLayout(primary.bounds(), primary.id(),
-                        target_bounds, target.id());
+    UpdateDisplayLayout(
+        primary.bounds(), primary.id(), target_bounds, target.id());
   }
 
   return true;
 }
 
-}  // namespace
-
-bool DisplayInfoProvider::SetInfo(const std::string& display_id,
-                                  const DisplayProperties& info,
-                                  std::string* error) {
-  return SetInfoImpl(display_id, info, error);
-}
-
-void DisplayInfoProvider::UpdateDisplayUnitInfoForPlatform(
+void DisplayInfoProviderChromeOS::UpdateDisplayUnitInfoForPlatform(
     const gfx::Display& display,
     extensions::api::system_display::DisplayUnitInfo* unit) {
-
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   unit->name = display_manager->GetDisplayNameForId(display.id());
   if (display_manager->IsMirrored()) {
     unit->mirroring_source_id =
         base::Int64ToString(display_manager->mirrored_display_id());
   }
 
   const float dpi = display.device_scale_factor() * kDpi96;
   unit->dpi_x = dpi;
   unit->dpi_y = dpi;
 
   const gfx::Insets overscan_insets =
       display_manager->GetOverscanInsets(display.id());
   unit->overscan.left = overscan_insets.left();
   unit->overscan.top = overscan_insets.top();
   unit->overscan.right = overscan_insets.right();
   unit->overscan.bottom = overscan_insets.bottom();
 }
 
+// static
+DisplayInfoProvider* DisplayInfoProvider::Create() {
+  return new DisplayInfoProviderChromeOS();
+}
+
 }  // namespace extensions