ozone: Add PRESUBMIT.py to check patch formatting

Review URL: https://codereview.chromium.org/698293002

Cr-Commit-Position: refs/heads/master@{#302638}

ui/ozone/PRESUBMIT.py

+# 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.
+
+"""Presubmit script for ozone.
+
+See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
+for more details about the presubmit API built into depot_tools.
+"""
+
+def CheckChangeOnUpload(input_api, output_api):
+  results = []
+  results += input_api.canned_checks.CheckPatchFormatted(input_api, output_api)
+  return results

ui/ozone/demo/ozone_demo.cc

@@ -66,18 +66,16 @@ class DemoWindow : public ui::PlatformWindowDelegate {
    }
 
   // PlatformWindowDelegate:
-  virtual void OnBoundsChanged(const gfx::Rect& new_bounds) override {}
-  virtual void OnDamageRect(const gfx::Rect& damaged_region) override {}
-  virtual void DispatchEvent(ui::Event* event) override {}
-  virtual void OnCloseRequest() override {
-    Quit();
-  }
-  virtual void OnClosed() override {}
-  virtual void OnWindowStateChanged(
-      ui::PlatformWindowState new_state) override {}
-  virtual void OnLostCapture() override {}
-  virtual void OnAcceleratedWidgetAvailable(
-      gfx::AcceleratedWidget widget) override {
+   virtual void OnBoundsChanged(const gfx::Rect& new_bounds) override {}
+   virtual void OnDamageRect(const gfx::Rect& damaged_region) override {}
+   virtual void DispatchEvent(ui::Event* event) override {}
+   virtual void OnCloseRequest() override { Quit(); }
+   virtual void OnClosed() override {}
+   virtual void OnWindowStateChanged(
+       ui::PlatformWindowState new_state) override {}
+   virtual void OnLostCapture() override {}
+   virtual void OnAcceleratedWidgetAvailable(
+       gfx::AcceleratedWidget widget) override {
     DCHECK_NE(widget, gfx::kNullAcceleratedWidget);
     widget_ = widget;
   }

ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.cc

@@ -48,11 +48,10 @@ class GLImageOzoneNativePixmapDmaBuf : public gfx::GLImageLinuxDMABuffer {
                                           unsigned internalformat)
       : GLImageLinuxDMABuffer(size, internalformat) {}
 
-  bool Initialize(NativePixmap* pixmap,
-                  gfx::GpuMemoryBuffer::Format format) {
+  bool Initialize(NativePixmap* pixmap, gfx::GpuMemoryBuffer::Format format) {
     base::FileDescriptor handle(pixmap->GetDmaBufFd(), false);
-    if (!GLImageLinuxDMABuffer::Initialize(
-            handle, format, pixmap->GetDmaBufPitch()))
+    if (!GLImageLinuxDMABuffer::Initialize(handle, format,
+                                           pixmap->GetDmaBufPitch()))
       return false;
     pixmap_ = pixmap;
     return true;

ui/ozone/platform/caca/caca_window.cc

@@ -104,9 +104,8 @@ void CacaWindow::OnCacaQuit() {
 
 void CacaWindow::OnCacaEvent(ui::Event* event) {
   DispatchEventFromNativeUiEvent(
-      event,
-      base::Bind(&PlatformWindowDelegate::DispatchEvent,
-                 base::Unretained(delegate_)));
+      event, base::Bind(&PlatformWindowDelegate::DispatchEvent,
+                        base::Unretained(delegate_)));
 }
 
 gfx::Rect CacaWindow::GetBounds() { return gfx::Rect(bitmap_size_); }

ui/ozone/platform/dri/crtc_controller.cc

@@ -31,10 +31,8 @@ CrtcController::~CrtcController() {
 }
 
 bool CrtcController::Modeset(const OverlayPlane& plane, drmModeModeInfo mode) {
-  if (!drm_->SetCrtc(crtc_,
-                     plane.buffer->GetFramebufferId(),
-                     std::vector<uint32_t>(1, connector_),
-                     &mode)) {
+  if (!drm_->SetCrtc(crtc_, plane.buffer->GetFramebufferId(),
+                     std::vector<uint32_t>(1, connector_), &mode)) {
     LOG(ERROR) << "Failed to modeset: error='" << strerror(errno)
                << "' crtc=" << crtc_ << " connector=" << connector_
                << " framebuffer_id=" << plane.buffer->GetFramebufferId()
@@ -94,10 +92,8 @@ bool CrtcController::SchedulePageFlip(const OverlayPlaneList& overlays) {
     const gfx::Size& size = plane.buffer->GetSize();
     gfx::RectF crop_rect = plane.crop_rect;
     crop_rect.Scale(size.width(), size.height());
-    if (!drm_->PageFlipOverlay(crtc_,
-                               plane.buffer->GetFramebufferId(),
-                               plane.display_bounds,
-                               crop_rect,
+    if (!drm_->PageFlipOverlay(crtc_, plane.buffer->GetFramebufferId(),
+                               plane.display_bounds, crop_rect,
                                plane.overlay_plane)) {
       LOG(ERROR) << "Cannot display on overlay: " << strerror(errno);
       return false;

ui/ozone/platform/dri/display_snapshot_dri.cc

@@ -123,9 +123,7 @@ DisplaySnapshotDri::~DisplaySnapshotDri() {
 std::string DisplaySnapshotDri::ToString() const {
   return base::StringPrintf(
       "[type=%d, connector=%" PRIu32 ", crtc=%" PRIu32 ", mode=%s, dim=%s]",
-      type_,
-      connector_,
-      crtc_,
+      type_, connector_, crtc_,
       current_mode_ ? current_mode_->ToString().c_str() : "NULL",
       physical_size_.ToString().c_str());
 }

ui/ozone/platform/dri/dri_cursor.cc

@@ -39,18 +39,16 @@ void DriCursor::SetCursor(gfx::AcceleratedWidget widget,
 void DriCursor::ShowCursor() {
   DCHECK_NE(cursor_window_, gfx::kNullAcceleratedWidget);
   if (cursor_.get())
-    hardware_->SetHardwareCursor(cursor_window_,
-                                 cursor_->bitmaps(),
-                                 bitmap_location(),
-                                 cursor_->frame_delay_ms());
+    hardware_->SetHardwareCursor(cursor_window_, cursor_->bitmaps(),
+                                 bitmap_location(), cursor_->frame_delay_ms());
   else
     HideCursor();
 }
 
 void DriCursor::HideCursor() {
   DCHECK_NE(cursor_window_, gfx::kNullAcceleratedWidget);
-  hardware_->SetHardwareCursor(
-      cursor_window_, std::vector<SkBitmap>(), gfx::Point(), 0);
+  hardware_->SetHardwareCursor(cursor_window_, std::vector<SkBitmap>(),
+                               gfx::Point(), 0);
 }
 
 void DriCursor::MoveCursorTo(gfx::AcceleratedWidget widget,

ui/ozone/platform/dri/dri_gpu_platform_support.cc

@@ -139,8 +139,7 @@ void DriGpuPlatformSupport::OnRefreshNativeDisplays(
   // their configuration immediately.
   for (size_t i = 0; i < native_displays.size(); ++i) {
     std::vector<DisplaySnapshot_Params>::const_iterator it =
-        std::find_if(cached_displays.begin(),
-                     cached_displays.end(),
+        std::find_if(cached_displays.begin(), cached_displays.end(),
                      FindDisplayById(native_displays[i]->display_id()));
 
     if (it == cached_displays.end())
@@ -183,8 +182,8 @@ void DriGpuPlatformSupport::OnConfigureNativeDisplay(
   // support panel fitting and they can use different modes even if the mode
   // isn't explicitly declared).
   if (!mode)
-    mode = ndd_->FindDisplayMode(
-        mode_param.size, mode_param.is_interlaced, mode_param.refresh_rate);
+    mode = ndd_->FindDisplayMode(mode_param.size, mode_param.is_interlaced,
+                                 mode_param.refresh_rate);
 
   if (!mode) {
     LOG(ERROR) << "Failed to find mode: size=" << mode_param.size.ToString()

ui/ozone/platform/dri/dri_gpu_platform_support_host.cc

@@ -49,10 +49,8 @@ void DriGpuPlatformSupportHost::RemoveChannelObserver(
 
 void DriGpuPlatformSupportHost::OnChannelEstablished(int host_id,
                                                      IPC::Sender* sender) {
-  TRACE_EVENT1("dri",
-               "DriGpuPlatformSupportHost::OnChannelEstablished",
-               "host_id",
-               host_id);
+  TRACE_EVENT1("dri", "DriGpuPlatformSupportHost::OnChannelEstablished",
+               "host_id", host_id);
   host_id_ = host_id;
   sender_ = sender;
 
@@ -64,21 +62,19 @@ void DriGpuPlatformSupportHost::OnChannelEstablished(int host_id,
   for (size_t i = 0; i < handlers_.size(); ++i)
     handlers_[i]->OnChannelEstablished(host_id, sender);
 
-  FOR_EACH_OBSERVER(
-      ChannelObserver, channel_observers_, OnChannelEstablished());
+  FOR_EACH_OBSERVER(ChannelObserver, channel_observers_,
+                    OnChannelEstablished());
 }
 
 void DriGpuPlatformSupportHost::OnChannelDestroyed(int host_id) {
-  TRACE_EVENT1("dri",
-               "DriGpuPlatformSupportHost::OnChannelDestroyed",
-               "host_id",
-               host_id);
+  TRACE_EVENT1("dri", "DriGpuPlatformSupportHost::OnChannelDestroyed",
+               "host_id", host_id);
   if (host_id_ == host_id) {
     host_id_ = -1;
     sender_ = NULL;
 
-    FOR_EACH_OBSERVER(
-        ChannelObserver, channel_observers_, OnChannelDestroyed());
+    FOR_EACH_OBSERVER(ChannelObserver, channel_observers_,
+                      OnChannelDestroyed());
   }
 
   for (size_t i = 0; i < handlers_.size(); ++i)

ui/ozone/platform/dri/dri_surface_factory.cc

@@ -123,10 +123,8 @@ void DriSurfaceFactory::SetHardwareCursor(gfx::AcceleratedWidget widget,
 
   if (cursor_frame_delay_ms_)
     cursor_timer_.Start(
-        FROM_HERE,
-        base::TimeDelta::FromMilliseconds(cursor_frame_delay_ms_),
-        this,
-        &DriSurfaceFactory::OnCursorAnimationTimeout);
+        FROM_HERE, base::TimeDelta::FromMilliseconds(cursor_frame_delay_ms_),
+        this, &DriSurfaceFactory::OnCursorAnimationTimeout);
 
   if (state_ != INITIALIZED)
     return;

ui/ozone/platform/dri/dri_surface_factory_unittest.cc

@@ -59,6 +59,7 @@ class DriSurfaceFactoryTest : public testing::Test {
 
   virtual void SetUp() override;
   virtual void TearDown() override;
+
  protected:
   scoped_ptr<base::MessageLoop> message_loop_;
   scoped_ptr<ui::MockDriWrapper> dri_;
@@ -78,8 +79,8 @@ void DriSurfaceFactoryTest::SetUp() {
   screen_manager_.reset(new MockScreenManager(dri_.get(),
                                               buffer_generator_.get()));
   window_delegate_manager_.reset(new ui::DriWindowDelegateManager());
-  factory_.reset(new ui::DriSurfaceFactory(
-      dri_.get(), screen_manager_.get(), window_delegate_manager_.get()));
+  factory_.reset(new ui::DriSurfaceFactory(dri_.get(), screen_manager_.get(),
+                                           window_delegate_manager_.get()));
 
   scoped_ptr<ui::DriWindowDelegate> window_delegate(
       new ui::DriWindowDelegateImpl(ui::DriSurfaceFactory::kDefaultWidgetHandle,
@@ -133,9 +134,7 @@ TEST_F(DriSurfaceFactoryTest, SetCursorImage) {
   std::vector<SkBitmap> cursor_bitmaps;
   cursor_bitmaps.push_back(image);
   factory_->SetHardwareCursor(ui::DriSurfaceFactory::kDefaultWidgetHandle,
-                              cursor_bitmaps,
-                              gfx::Point(4, 2),
-                              0);
+                              cursor_bitmaps, gfx::Point(4, 2), 0);
 
   SkBitmap cursor;
   // Buffers 0 and 1 are the cursor buffers.

ui/ozone/platform/dri/dri_window.cc

@@ -111,9 +111,8 @@ bool DriWindow::CanDispatchEvent(const PlatformEvent& ne) {
 
 uint32_t DriWindow::DispatchEvent(const PlatformEvent& native_event) {
   DispatchEventFromNativeUiEvent(
-      native_event,
-      base::Bind(&PlatformWindowDelegate::DispatchEvent,
-                 base::Unretained(delegate_)));
+      native_event, base::Bind(&PlatformWindowDelegate::DispatchEvent,
+                               base::Unretained(delegate_)));
   return POST_DISPATCH_STOP_PROPAGATION;
 }
 

ui/ozone/platform/dri/dri_window_delegate_impl.cc

@@ -34,12 +34,8 @@ HardwareDisplayController* DriWindowDelegateImpl::GetController() {
 }
 
 void DriWindowDelegateImpl::OnBoundsChanged(const gfx::Rect& bounds) {
-  TRACE_EVENT2("dri",
-               "DriWindowDelegateImpl::OnBoundsChanged",
-               "widget",
-               widget_,
-               "bounds",
-               bounds.ToString());
+  TRACE_EVENT2("dri", "DriWindowDelegateImpl::OnBoundsChanged", "widget",
+               widget_, "bounds", bounds.ToString());
   controller_ = screen_manager_->GetDisplayController(bounds);
 }
 

ui/ozone/platform/dri/dri_wrapper.cc

@@ -89,11 +89,7 @@ bool DriWrapper::SetCrtc(uint32_t crtc_id,
   DCHECK(!connectors.empty());
   DCHECK(mode);
 
-  TRACE_EVENT2("dri",
-               "DriWrapper::SetCrtc",
-               "crtc",
-               crtc_id,
-               "size",
+  TRACE_EVENT2("dri", "DriWrapper::SetCrtc", "crtc", crtc_id, "size",
                gfx::Size(mode->hdisplay, mode->vdisplay).ToString());
   return !drmModeSetCrtc(fd_,
                          crtc_id,

ui/ozone/platform/dri/gbm_buffer.cc

@@ -69,9 +69,7 @@ GbmPixmap::GbmPixmap(scoped_refptr<GbmBuffer> buffer)
 }
 
 bool GbmPixmap::Initialize(DriWrapper* dri) {
-  if (drmPrimeHandleToFD(dri->get_fd(),
-                         buffer_->GetHandle(),
-                         DRM_CLOEXEC,
+  if (drmPrimeHandleToFD(dri->get_fd(), buffer_->GetHandle(), DRM_CLOEXEC,
                          &dma_buf_)) {
     LOG(ERROR) << "Failed to export buffer to dma_buf";
     return false;

ui/ozone/platform/dri/hardware_display_controller.cc

@@ -175,8 +175,7 @@ void HardwareDisplayController::AddCrtc(scoped_ptr<CrtcController> controller) {
 scoped_ptr<CrtcController> HardwareDisplayController::RemoveCrtc(
     uint32_t crtc) {
   for (ScopedVector<CrtcController>::iterator it = crtc_controllers_.begin();
-       it != crtc_controllers_.end();
-       ++it) {
+       it != crtc_controllers_.end(); ++it) {
     if ((*it)->crtc() == crtc) {
       scoped_ptr<CrtcController> controller(*it);
       crtc_controllers_.weak_erase(it);

ui/ozone/platform/dri/hardware_display_controller_unittest.cc

@@ -30,7 +30,7 @@ class MockScanoutBuffer : public ui::ScanoutBuffer {
   MockScanoutBuffer(const gfx::Size& size) : size_(size) {}
 
   // ScanoutBuffer:
-  virtual uint32_t GetFramebufferId() const override {return 0; }
+  virtual uint32_t GetFramebufferId() const override { return 0; }
   virtual uint32_t GetHandle() const override { return 0; }
   virtual gfx::Size GetSize() const override { return size_; }
 
@@ -51,6 +51,7 @@ class HardwareDisplayControllerTest : public testing::Test {
 
   virtual void SetUp() override;
   virtual void TearDown() override;
+
  protected:
   scoped_ptr<ui::HardwareDisplayController> controller_;
   scoped_ptr<ui::MockDriWrapper> drm_;

ui/ozone/platform/dri/native_display_delegate_dri.cc

@@ -150,8 +150,7 @@ void NativeDisplayDelegateDri::ForceDPMSOn() {
     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);
   }
 }
 
@@ -162,13 +161,12 @@ std::vector<DisplaySnapshot*> NativeDisplayDelegateDri::GetDisplays() {
   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());
@@ -195,9 +193,7 @@ bool NativeDisplayDelegateDri::Configure(const DisplaySnapshot& output,
 
   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();
@@ -270,8 +266,7 @@ bool NativeDisplayDelegateDri::SetHDCPState(const DisplaySnapshot& output,
   }
 
   return dri_->SetProperty(
-      dri_output.connector(),
-      hdcp_property->prop_id,
+      dri_output.connector(), hdcp_property->prop_id,
       GetContentProtectionValue(hdcp_property.get(), state));
 }
 
@@ -303,8 +298,8 @@ void NativeDisplayDelegateDri::OnDeviceEvent(const DeviceEvent& event) {
 
   if (event.action_type() == DeviceEvent::CHANGE) {
     VLOG(1) << "Got display changed event";
-    FOR_EACH_OBSERVER(
-        NativeDisplayObserver, observers_, OnConfigurationChanged());
+    FOR_EACH_OBSERVER(NativeDisplayObserver, observers_,
+                      OnConfigurationChanged());
   }
 }
 
@@ -313,8 +308,7 @@ void NativeDisplayDelegateDri::NotifyScreenManager(
     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())
@@ -323,13 +317,12 @@ void NativeDisplayDelegateDri::NotifyScreenManager(
 
   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());
   }
 }
 

ui/ozone/platform/dri/native_display_delegate_dri.h

@@ -51,8 +51,8 @@ class NativeDisplayDelegateDri : public NativeDisplayDelegate,
   virtual bool SetHDCPState(const DisplaySnapshot& output,
                             HDCPState state) override;
   virtual std::vector<ui::ColorCalibrationProfile>
-      GetAvailableColorCalibrationProfiles(
-          const ui::DisplaySnapshot& output) override;
+  GetAvailableColorCalibrationProfiles(
+      const ui::DisplaySnapshot& output) override;
   virtual bool SetColorCalibrationProfile(
       const ui::DisplaySnapshot& output,
       ui::ColorCalibrationProfile new_profile) override;

ui/ozone/platform/dri/native_display_delegate_proxy.cc

@@ -155,8 +155,8 @@ void NativeDisplayDelegateProxy::OnUpdateNativeDisplays(
   for (size_t i = 0; i < displays.size(); ++i)
     displays_.push_back(new DisplaySnapshotProxy(displays[i]));
 
-  FOR_EACH_OBSERVER(
-      NativeDisplayObserver, observers_, OnConfigurationChanged());
+  FOR_EACH_OBSERVER(NativeDisplayObserver, observers_,
+                    OnConfigurationChanged());
 }
 
 }  // namespace ui

ui/ozone/platform/dri/native_display_delegate_proxy.h

@@ -46,8 +46,7 @@ class NativeDisplayDelegateProxy : public NativeDisplayDelegate,
   virtual bool SetHDCPState(const DisplaySnapshot& output,
                             HDCPState state) override;
   virtual std::vector<ColorCalibrationProfile>
-      GetAvailableColorCalibrationProfiles(
-          const DisplaySnapshot& output) override;
+  GetAvailableColorCalibrationProfiles(const DisplaySnapshot& output) override;
   virtual bool SetColorCalibrationProfile(
       const DisplaySnapshot& output,
       ColorCalibrationProfile new_profile) override;

ui/ozone/platform/dri/ozone_platform_dri.cc

@@ -64,11 +64,8 @@ class OzonePlatformDri : public OzonePlatform {
       PlatformWindowDelegate* delegate,
       const gfx::Rect& bounds) override {
     scoped_ptr<DriWindow> platform_window(
-        new DriWindow(delegate,
-                      bounds,
-                      gpu_platform_support_host_.get(),
-                      event_factory_ozone_.get(),
-                      window_manager_.get()));
+        new DriWindow(delegate, bounds, gpu_platform_support_host_.get(),
+                      event_factory_ozone_.get(), window_manager_.get()));
     platform_window->Initialize();
     return platform_window.Pass();
   }
@@ -81,11 +78,9 @@ class OzonePlatformDri : public OzonePlatform {
     dri_->Initialize();
     surface_factory_ozone_.reset(new DriSurfaceFactory(
         dri_.get(), screen_manager_.get(), &window_delegate_manager_));
-    gpu_platform_support_.reset(
-        new DriGpuPlatformSupport(surface_factory_ozone_.get(),
-                                  &window_delegate_manager_,
-                                  screen_manager_.get(),
-                                  scoped_ptr<NativeDisplayDelegateDri>()));
+    gpu_platform_support_.reset(new DriGpuPlatformSupport(
+        surface_factory_ozone_.get(), &window_delegate_manager_,
+        screen_manager_.get(), scoped_ptr<NativeDisplayDelegateDri>()));
     gpu_platform_support_host_.reset(new DriGpuPlatformSupportHost());
     cursor_factory_ozone_.reset(new BitmapCursorFactoryOzone);
     window_manager_.reset(new DriWindowManager(surface_factory_ozone_.get()));

ui/ozone/platform/dri/ozone_platform_gbm.cc

@@ -97,11 +97,8 @@ class OzonePlatformGbm : public OzonePlatform {
       PlatformWindowDelegate* delegate,
       const gfx::Rect& bounds) override {
     scoped_ptr<DriWindow> platform_window(
-        new DriWindow(delegate,
-                      bounds,
-                      gpu_platform_support_host_.get(),
-                      event_factory_ozone_.get(),
-                      window_manager_.get()));
+        new DriWindow(delegate, bounds, gpu_platform_support_host_.get(),
+                      event_factory_ozone_.get(), window_manager_.get()));
     platform_window->Initialize();
     return platform_window.Pass();
   }
@@ -133,13 +130,11 @@ class OzonePlatformGbm : public OzonePlatform {
     if (!surface_factory_ozone_)
       surface_factory_ozone_.reset(new GbmSurfaceFactory(use_surfaceless_));
 
-    surface_factory_ozone_->InitializeGpu(dri_.get(),
-                                          buffer_generator_->device(),
-                                          screen_manager_.get(),
-                                          window_delegate_manager_.get());
+    surface_factory_ozone_->InitializeGpu(
+        dri_.get(), buffer_generator_->device(), screen_manager_.get(),
+        window_delegate_manager_.get());
     gpu_platform_support_.reset(new DriGpuPlatformSupport(
-        surface_factory_ozone_.get(),
-        window_delegate_manager_.get(),
+        surface_factory_ozone_.get(), window_delegate_manager_.get(),
         screen_manager_.get(),
         scoped_ptr<NativeDisplayDelegateDri>(new NativeDisplayDelegateDri(
             dri_.get(), screen_manager_.get(), NULL))));

ui/ozone/platform/dri/screen_manager.cc

@@ -56,8 +56,8 @@ bool ScreenManager::ConfigureDisplayController(uint32_t crtc,
                                                uint32_t connector,
                                                const gfx::Point& origin,
                                                const drmModeModeInfo& mode) {
-  gfx::Rect modeset_bounds(
-      origin.x(), origin.y(), mode.hdisplay, mode.vdisplay);
+  gfx::Rect modeset_bounds(origin.x(), origin.y(), mode.hdisplay,
+                           mode.vdisplay);
   HardwareDisplayControllers::iterator it = FindDisplayController(crtc);
   DCHECK(controllers_.end() != it) << "Display controller (crtc=" << crtc
                                    << ") doesn't exist.";
@@ -164,8 +164,7 @@ void ScreenManager::ForceInitializationOfPrimaryDisplay() {
                       dpms->prop_id,
                       DRM_MODE_DPMS_ON);
 
-  AddDisplayController(dri_,
-                       displays[0]->crtc()->crtc_id,
+  AddDisplayController(dri_, displays[0]->crtc()->crtc_id,
                        displays[0]->connector()->connector_id);
   ConfigureDisplayController(displays[0]->crtc()->crtc_id,
                              displays[0]->connector()->connector_id,

ui/ozone/platform/dri/screen_manager_unittest.cc

@@ -75,8 +75,8 @@ TEST_F(ScreenManagerTest, CheckWithNoControllers) {
 }
 
 TEST_F(ScreenManagerTest, CheckWithValidController) {
-  screen_manager_->AddDisplayController(
-      dri_.get(), kPrimaryCrtc, kPrimaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kPrimaryCrtc,
+                                        kPrimaryConnector);
   screen_manager_->ConfigureDisplayController(kPrimaryCrtc,
                                               kPrimaryConnector,
                                               GetPrimaryBounds().origin(),
@@ -89,8 +89,8 @@ TEST_F(ScreenManagerTest, CheckWithValidController) {
 }
 
 TEST_F(ScreenManagerTest, CheckWithInvalidBounds) {
-  screen_manager_->AddDisplayController(
-      dri_.get(), kPrimaryCrtc, kPrimaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kPrimaryCrtc,
+                                        kPrimaryConnector);
   screen_manager_->ConfigureDisplayController(kPrimaryCrtc,
                                               kPrimaryConnector,
                                               GetPrimaryBounds().origin(),
@@ -101,26 +101,25 @@ TEST_F(ScreenManagerTest, CheckWithInvalidBounds) {
 }
 
 TEST_F(ScreenManagerTest, CheckForSecondValidController) {
-  screen_manager_->AddDisplayController(
-      dri_.get(), kPrimaryCrtc, kPrimaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kPrimaryCrtc,
+                                        kPrimaryConnector);
   screen_manager_->ConfigureDisplayController(kPrimaryCrtc,
                                               kPrimaryConnector,
                                               GetPrimaryBounds().origin(),
                                               kDefaultMode);
-  screen_manager_->AddDisplayController(
-      dri_.get(), kSecondaryCrtc, kSecondaryConnector);
-  screen_manager_->ConfigureDisplayController(kSecondaryCrtc,
-                                              kSecondaryConnector,
-                                              GetSecondaryBounds().origin(),
-                                              kDefaultMode);
+  screen_manager_->AddDisplayController(dri_.get(), kSecondaryCrtc,
+                                        kSecondaryConnector);
+  screen_manager_->ConfigureDisplayController(
+      kSecondaryCrtc, kSecondaryConnector, GetSecondaryBounds().origin(),
+      kDefaultMode);
 
   EXPECT_TRUE(screen_manager_->GetDisplayController(GetPrimaryBounds()));
   EXPECT_TRUE(screen_manager_->GetDisplayController(GetSecondaryBounds()));
 }
 
 TEST_F(ScreenManagerTest, CheckControllerAfterItIsRemoved) {
-  screen_manager_->AddDisplayController(
-      dri_.get(), kPrimaryCrtc, kPrimaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kPrimaryCrtc,
+                                        kPrimaryConnector);
   screen_manager_->ConfigureDisplayController(kPrimaryCrtc,
                                               kPrimaryConnector,
                                               GetPrimaryBounds().origin(),
@@ -134,8 +133,8 @@ TEST_F(ScreenManagerTest, CheckControllerAfterItIsRemoved) {
 }
 
 TEST_F(ScreenManagerTest, CheckDuplicateConfiguration) {
-  screen_manager_->AddDisplayController(
-      dri_.get(), kPrimaryCrtc, kPrimaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kPrimaryCrtc,
+                                        kPrimaryConnector);
   screen_manager_->ConfigureDisplayController(kPrimaryCrtc,
                                               kPrimaryConnector,
                                               GetPrimaryBounds().origin(),
@@ -150,8 +149,8 @@ TEST_F(ScreenManagerTest, CheckDuplicateConfiguration) {
 }
 
 TEST_F(ScreenManagerTest, CheckChangingMode) {
-  screen_manager_->AddDisplayController(
-      dri_.get(), kPrimaryCrtc, kPrimaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kPrimaryCrtc,
+                                        kPrimaryConnector);
   screen_manager_->ConfigureDisplayController(kPrimaryCrtc,
                                               kPrimaryConnector,
                                               GetPrimaryBounds().origin(),
@@ -171,14 +170,14 @@ TEST_F(ScreenManagerTest, CheckChangingMode) {
 }
 
 TEST_F(ScreenManagerTest, CheckForControllersInMirroredMode) {
-  screen_manager_->AddDisplayController(
-      dri_.get(), kPrimaryCrtc, kPrimaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kPrimaryCrtc,
+                                        kPrimaryConnector);
   screen_manager_->ConfigureDisplayController(kPrimaryCrtc,
                                               kPrimaryConnector,
                                               GetPrimaryBounds().origin(),
                                               kDefaultMode);
-  screen_manager_->AddDisplayController(
-      dri_.get(), kSecondaryCrtc, kSecondaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kSecondaryCrtc,
+                                        kSecondaryConnector);
   screen_manager_->ConfigureDisplayController(kSecondaryCrtc,
                                               kSecondaryConnector,
                                               GetPrimaryBounds().origin(),
@@ -189,14 +188,14 @@ TEST_F(ScreenManagerTest, CheckForControllersInMirroredMode) {
 }
 
 TEST_F(ScreenManagerTest, CheckMirrorModeTransitions) {
-  screen_manager_->AddDisplayController(
-      dri_.get(), kPrimaryCrtc, kPrimaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kPrimaryCrtc,
+                                        kPrimaryConnector);
   screen_manager_->ConfigureDisplayController(kPrimaryCrtc,
                                               kPrimaryConnector,
                                               GetPrimaryBounds().origin(),
                                               kDefaultMode);
-  screen_manager_->AddDisplayController(
-      dri_.get(), kSecondaryCrtc, kSecondaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kSecondaryCrtc,
+                                        kSecondaryConnector);
   screen_manager_->ConfigureDisplayController(kSecondaryCrtc,
                                               kSecondaryConnector,
                                               GetSecondaryBounds().origin(),
@@ -229,14 +228,14 @@ TEST_F(ScreenManagerTest, CheckMirrorModeTransitions) {
 }
 
 TEST_F(ScreenManagerTest, MonitorGoneInMirrorMode) {
-  screen_manager_->AddDisplayController(
-      dri_.get(), kPrimaryCrtc, kPrimaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kPrimaryCrtc,
+                                        kPrimaryConnector);
   screen_manager_->ConfigureDisplayController(kPrimaryCrtc,
                                               kPrimaryConnector,
                                               GetPrimaryBounds().origin(),
                                               kDefaultMode);
-  screen_manager_->AddDisplayController(
-      dri_.get(), kSecondaryCrtc, kSecondaryConnector);
+  screen_manager_->AddDisplayController(dri_.get(), kSecondaryCrtc,
+                                        kSecondaryConnector);
   screen_manager_->ConfigureDisplayController(kSecondaryCrtc,
                                               kSecondaryConnector,
                                               GetPrimaryBounds().origin(),

ui/ozone/platform/egltest/ozone_platform_egltest.cc

@@ -151,9 +151,8 @@ bool EgltestWindow::CanDispatchEvent(const ui::PlatformEvent& ne) {
 
 uint32_t EgltestWindow::DispatchEvent(const ui::PlatformEvent& native_event) {
   DispatchEventFromNativeUiEvent(
-      native_event,
-      base::Bind(&PlatformWindowDelegate::DispatchEvent,
-                 base::Unretained(delegate_)));
+      native_event, base::Bind(&PlatformWindowDelegate::DispatchEvent,
+                               base::Unretained(delegate_)));
 
   return ui::POST_DISPATCH_STOP_PROPAGATION;
 }