ozone: Add PRESUBMIT.py to check patch formatting

ui/ozone/platform/dri/native_display_delegate_dri.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 "ui/ozone/platform/dri/native_display_delegate_dri.h"
 
 #include "base/bind.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/display/types/native_display_observer.h"
 #include "ui/events/ozone/device/device_event.h"
@@ skipping 132 matching lines @@
 void NativeDisplayDelegateDri::SetBackgroundColor(uint32_t color_argb) {
   if (console_buffer_)
     console_buffer_->canvas()->clear(color_argb);
 }
 
 void NativeDisplayDelegateDri::ForceDPMSOn() {
   for (size_t i = 0; i < cached_displays_.size(); ++i) {
     DisplaySnapshotDri* dri_output = cached_displays_[i];
     if (dri_output->dpms_property())
       dri_->SetProperty(dri_output->connector(),
-                        dri_output->dpms_property()->prop_id,
-                        DRM_MODE_DPMS_ON);
+                        dri_output->dpms_property()->prop_id, DRM_MODE_DPMS_ON);
   }
 }
 
 std::vector<DisplaySnapshot*> NativeDisplayDelegateDri::GetDisplays() {
   ScopedVector<DisplaySnapshotDri> old_displays(cached_displays_.Pass());
   cached_modes_.clear();
 
   ScopedVector<HardwareDisplayControllerInfo> displays =
       GetAvailableDisplayControllerInfos(dri_->get_fd());
   for (size_t i = 0;
-       i < displays.size() && cached_displays_.size() < kMaxDisplayCount;
-       ++i) {
+       i < displays.size() && cached_displays_.size() < kMaxDisplayCount; ++i) {
     DisplaySnapshotDri* display = new DisplaySnapshotDri(
         dri_, displays[i]->connector(), displays[i]->crtc(), i);
     cached_displays_.push_back(display);
-    cached_modes_.insert(
-        cached_modes_.end(), display->modes().begin(), display->modes().end());
+    cached_modes_.insert(cached_modes_.end(), display->modes().begin(),
+                         display->modes().end());
   }
 
   NotifyScreenManager(cached_displays_.get(), old_displays.get());
 
   std::vector<DisplaySnapshot*> generic_displays(cached_displays_.begin(),
                                                  cached_displays_.end());
   return generic_displays;
 }
 
 void NativeDisplayDelegateDri::AddMode(const DisplaySnapshot& output,
                                        const DisplayMode* mode) {
 }
 
 bool NativeDisplayDelegateDri::Configure(const DisplaySnapshot& output,
                                          const DisplayMode* mode,
                                          const gfx::Point& origin) {
   const DisplaySnapshotDri& dri_output =
       static_cast<const DisplaySnapshotDri&>(output);
 
   VLOG(1) << "DRM configuring: crtc=" << dri_output.crtc()
           << " connector=" << dri_output.connector()
           << " origin=" << origin.ToString()
           << " size=" << (mode ? mode->size().ToString() : "0x0");
 
   if (mode) {
     if (!screen_manager_->ConfigureDisplayController(
-            dri_output.crtc(),
-            dri_output.connector(),
-            origin,
+            dri_output.crtc(), dri_output.connector(), origin,
             static_cast<const DisplayModeDri*>(mode)->mode_info())) {
       VLOG(1) << "Failed to configure: crtc=" << dri_output.crtc()
               << " connector=" << dri_output.connector();
       return false;
     }
   } else {
     if (!screen_manager_->DisableDisplayController(dri_output.crtc())) {
       VLOG(1) << "Failed to disable crtc=" << dri_output.crtc();
       return false;
     }
@@ skipping 52 matching lines @@
   }
 
   ScopedDrmPropertyPtr hdcp_property(
       dri_->GetProperty(connector.get(), kContentProtection));
   if (!hdcp_property) {
     LOG(ERROR) << "'" << kContentProtection << "' property doesn't exist.";
     return false;
   }
 
   return dri_->SetProperty(
-      dri_output.connector(),
-      hdcp_property->prop_id,
+      dri_output.connector(), hdcp_property->prop_id,
       GetContentProtectionValue(hdcp_property.get(), state));
 }
 
 std::vector<ui::ColorCalibrationProfile>
 NativeDisplayDelegateDri::GetAvailableColorCalibrationProfiles(
     const ui::DisplaySnapshot& output) {
   NOTIMPLEMENTED();
   return std::vector<ui::ColorCalibrationProfile>();
 }
 
@@ skipping 11 matching lines @@
 void NativeDisplayDelegateDri::RemoveObserver(NativeDisplayObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void NativeDisplayDelegateDri::OnDeviceEvent(const DeviceEvent& event) {
   if (event.device_type() != DeviceEvent::DISPLAY)
     return;
 
   if (event.action_type() == DeviceEvent::CHANGE) {
     VLOG(1) << "Got display changed event";
-    FOR_EACH_OBSERVER(
-        NativeDisplayObserver, observers_, OnConfigurationChanged());
+    FOR_EACH_OBSERVER(NativeDisplayObserver, observers_,
+                      OnConfigurationChanged());
   }
 }
 
 void NativeDisplayDelegateDri::NotifyScreenManager(
     const std::vector<DisplaySnapshotDri*>& new_displays,
     const std::vector<DisplaySnapshotDri*>& old_displays) const {
   for (size_t i = 0; i < old_displays.size(); ++i) {
     const std::vector<DisplaySnapshotDri*>::const_iterator it =
-        std::find_if(new_displays.begin(),
-                     new_displays.end(),
+        std::find_if(new_displays.begin(), new_displays.end(),
                      DisplaySnapshotComparator(old_displays[i]));
 
     if (it == new_displays.end())
       screen_manager_->RemoveDisplayController(old_displays[i]->crtc());
   }
 
   for (size_t i = 0; i < new_displays.size(); ++i) {
     const std::vector<DisplaySnapshotDri*>::const_iterator it =
-        std::find_if(old_displays.begin(),
-                     old_displays.end(),
+        std::find_if(old_displays.begin(), old_displays.end(),
                      DisplaySnapshotComparator(new_displays[i]));
 
     if (it == old_displays.end())
-      screen_manager_->AddDisplayController(
-          dri_, new_displays[i]->crtc(), new_displays[i]->connector());
+      screen_manager_->AddDisplayController(dri_, new_displays[i]->crtc(),
+                                            new_displays[i]->connector());
   }
 }
 
 }  // namespace ui