Mandoline: Rename components/view_manager to components/mus

components/mus/surfaces/top_level_display_client.cc

 // Copyright 2015 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 "components/view_manager/surfaces/top_level_display_client.h"
+#include "components/mus/surfaces/top_level_display_client.h"
 
 #include "cc/output/compositor_frame.h"
 #include "cc/surfaces/display.h"
-#include "components/view_manager/gles2/gpu_state.h"
-#include "components/view_manager/surfaces/surfaces_context_provider.h"
-#include "components/view_manager/surfaces/surfaces_output_surface.h"
-#include "components/view_manager/surfaces/surfaces_scheduler.h"
-#include "components/view_manager/surfaces/surfaces_state.h"
+#include "components/mus/gles2/gpu_state.h"
+#include "components/mus/surfaces/surfaces_context_provider.h"
+#include "components/mus/surfaces/surfaces_output_surface.h"
+#include "components/mus/surfaces/surfaces_scheduler.h"
+#include "components/mus/surfaces/surfaces_state.h"
 
 namespace surfaces {
 namespace {
 void CallCallback(const base::Closure& callback, cc::SurfaceDrawStatus status) {
   callback.Run();
 }
 }
 
 TopLevelDisplayClient::TopLevelDisplayClient(
     gfx::AcceleratedWidget widget,
@@ skipping 15 matching lines @@
       make_scoped_ptr(new surfaces::DirectOutputSurface(
           new SurfacesContextProvider(this, widget, gpu_state))),
       null_display_scheduler);
 
   display_->Resize(last_submitted_frame_size_);
 
   // TODO(fsamuel): Plumb the proper device scale factor.
   display_->SetSurfaceId(cc_id_, 1.f /* device_scale_factor */);
 }
 
-void TopLevelDisplayClient::OnContextCreated() {
-}
+void TopLevelDisplayClient::OnContextCreated() {}
 
 TopLevelDisplayClient::~TopLevelDisplayClient() {
   if (display_) {
     factory_.Destroy(cc_id_);
     surfaces_state_->scheduler()->RemoveDisplay(display_.get());
     // By deleting the object after display_ is reset, OutputSurfaceLost can
     // know not to do anything (which would result in double delete).
     delete display_.release();
   }
 }
 
 void TopLevelDisplayClient::SubmitCompositorFrame(
     scoped_ptr<cc::CompositorFrame> frame,
     const base::Closure& callback) {
   pending_frame_ = frame.Pass();
 
   last_submitted_frame_size_ =
-      pending_frame_->delegated_frame_data->render_pass_list.back()->
-          output_rect.size();
+      pending_frame_->delegated_frame_data->render_pass_list.back()
+          ->output_rect.size();
   display_->Resize(last_submitted_frame_size_);
   factory_.SubmitCompositorFrame(cc_id_, pending_frame_.Pass(),
                                  base::Bind(&CallCallback, callback));
   surfaces_state_->scheduler()->SetNeedsDraw();
 }
 
 void TopLevelDisplayClient::CommitVSyncParameters(base::TimeTicks timebase,
-                                                  base::TimeDelta interval) {
-}
+                                                  base::TimeDelta interval) {}
 
 void TopLevelDisplayClient::OutputSurfaceLost() {
   if (!display_)  // Shutdown case
     return;
 
   // If our OutputSurface is lost we can't draw until we get a new one. For now,
   // destroy the display and create a new one when our ContextProvider provides
   // a new one.
   // TODO: This is more violent than necessary - we could simply remove this
   // display from the scheduler's set and pass a new context in to the
   // OutputSurface. It should be able to reinitialize properly.
   surfaces_state_->scheduler()->RemoveDisplay(display_.get());
   display_.reset();
 }
 
 void TopLevelDisplayClient::SetMemoryPolicy(
-    const cc::ManagedMemoryPolicy& policy) {
-}
+    const cc::ManagedMemoryPolicy& policy) {}
 
 void TopLevelDisplayClient::OnVSyncParametersUpdated(int64_t timebase,
                                                      int64_t interval) {
   surfaces_state_->scheduler()->OnVSyncParametersUpdated(
       base::TimeTicks::FromInternalValue(timebase),
       base::TimeDelta::FromInternalValue(interval));
 }
 
 void TopLevelDisplayClient::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   // TODO(fsamuel): Implement this.
 }
 
 }  // namespace surfaces