exo: Use aura::Windows instead of views::Views as exo::Surfaces.

components/exo/surface.h

 // 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.
 
 #ifndef COMPONENTS_EXO_SURFACE_H_
 #define COMPONENTS_EXO_SURFACE_H_
 
 #include <list>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "third_party/skia/include/core/SkRegion.h"
+#include "ui/aura/window.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/gfx/geometry/rect.h"
-#include "ui/views/view.h"
 
 namespace base {
 namespace trace_event {
 class TracedValue;
 }
 }
 
 namespace exo {
 class Buffer;
 class SurfaceDelegate;
 class SurfaceObserver;
 
 // This class represents a rectangular area that is displayed on the screen.
 // It has a location, size and pixel contents.
-class Surface : public views::View, public ui::CompositorObserver {
+class Surface : public aura::Window, public ui::CompositorObserver {
  public:
   Surface();
   ~Surface() override;
 
   // Set a buffer as the content of this surface. A buffer can only be attached
   // to one surface at a time.
   void Attach(Buffer* buffer);
 
   // Describe the regions where the pending buffer is different from the
   // current surface contents, and where the surface therefore needs to be
@@ skipping 23 matching lines @@
   void Commit();
 
   // This will synchronously commit all pending state of the surface and its
   // descendants by recursively calling CommitSurfaceHierarchy() for each
   // sub-surface with pending state.
   void CommitSurfaceHierarchy();
 
   // Returns true if surface is in synchronized mode.
   bool IsSynchronized() const;
 
+  // Returns the preferred size of surface.
+  gfx::Size GetPreferredSize() const;
+
   // Set the surface delegate.
   void SetSurfaceDelegate(SurfaceDelegate* delegate);
 
   // Returns true if surface has been assigned a surface delegate.
   bool HasSurfaceDelegate() const;
 
   // Surface does not own observers. It is the responsibility of the observer
   // to remove itself when it is done observing.
   void AddSurfaceObserver(SurfaceObserver* observer);
   void RemoveSurfaceObserver(SurfaceObserver* observer);
   bool HasSurfaceObserver(const SurfaceObserver* observer) const;
 
   // Returns a trace value representing the state of the surface.
   scoped_refptr<base::trace_event::TracedValue> AsTracedValue() const;
 
   bool HasPendingDamageForTesting() const { return !pending_damage_.IsEmpty(); }
 
-  // Overridden from views::View:
-  gfx::Size GetPreferredSize() const override;
-
   // Overridden from ui::CompositorObserver:
   void OnCompositingDidCommit(ui::Compositor* compositor) override;
   void OnCompositingStarted(ui::Compositor* compositor,
                             base::TimeTicks start_time) override;
   void OnCompositingEnded(ui::Compositor* compositor) override;
   void OnCompositingAborted(ui::Compositor* compositor) override;
   void OnCompositingLockStateChanged(ui::Compositor* compositor) override {}
   void OnCompositingShuttingDown(ui::Compositor* compositor) override;
 
  private:
@@ skipping 57 matching lines @@
 
   // Surface observer list. Surface does not own the observers.
   base::ObserverList<SurfaceObserver, true> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(Surface);
 };
 
 }  // namespace exo
 
 #endif  // COMPONENTS_EXO_SURFACE_H_