exo: Remove TextureLayer implementation of Surface.

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 <memory>
 #include <set>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "cc/resources/transferable_resource.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/aura/window.h"
-#include "ui/aura/window_observer.h"
-#include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/layer_owner_delegate.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace base {
 namespace trace_event {
 class TracedValue;
 }
 }
 
 namespace cc {
@@ skipping 39 matching lines @@
            std::pair<scoped_refptr<SurfaceFactoryOwner>,
                      std::unique_ptr<cc::SingleReleaseCallback>>>
       release_callbacks_;
   std::unique_ptr<cc::SurfaceIdAllocator> id_allocator_;
   std::unique_ptr<cc::SurfaceFactory> surface_factory_;
   Surface* surface_;
 };
 
 // This class represents a rectangular area that is displayed on the screen.
 // It has a location, size and pixel contents.
-class Surface : public aura::WindowObserver,
-                public ui::LayerOwnerDelegate,
-                public ui::CompositorObserver {
+class Surface : public ui::LayerOwnerDelegate {
  public:
   Surface();
   ~Surface() override;
 
   // Type-checking downcast routine.
   static Surface* AsSurface(const aura::Window* window);
 
-  // Sets whether to put the contents in a SurfaceLayer or a TextureLayer.
-  static void SetUseSurfaceLayer(bool use_surface_layer);
-
   aura::Window* window() { return window_.get(); }
 
   // 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
   // repainted.
   void Damage(const gfx::Rect& rect);
@@ skipping 87 matching lines @@
   void RemoveSurfaceObserver(SurfaceObserver* observer);
   bool HasSurfaceObserver(const SurfaceObserver* observer) const;
 
   // Returns a trace value representing the state of the surface.
   std::unique_ptr<base::trace_event::TracedValue> AsTracedValue() const;
 
   bool HasPendingDamageForTesting(const gfx::Rect& damage) const {
     return pending_damage_.contains(gfx::RectToSkIRect(damage));
   }
 
-  // Overridden from aura::WindowObserver:
-  void OnWindowAddedToRootWindow(aura::Window* window) override;
-  void OnWindowRemovingFromRootWindow(aura::Window* window,
-                                      aura::Window* new_root) override;
-
   // Overridden from ui::LayerOwnerDelegate:
   void OnLayerRecreated(ui::Layer* old_layer, ui::Layer* new_layer) 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;
-
   void WillDraw(cc::SurfaceId surface_id);
 
   // Check whether this Surface and its children need to create new cc::Surface
   // IDs for their contents next time they get new buffer contents.
   void CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces();
 
  private:
   struct State {
     State();
     ~State();
@@ skipping 16 matching lines @@
     return needs_commit_surface_hierarchy_;
   }
 
   // Returns true if this surface or any child surface needs a commit and has
   // has_pending_layer_changes_ true.
   bool HasLayerHierarchyChanged() const;
 
   // Sets that all children must create new cc::SurfaceIds for their contents.
   void SetSurfaceHierarchyNeedsCommitToNewSurfaces();
 
-  // Commit the current attached buffer to a TextureLayer.
-  void CommitTextureContents();
-
-  // Commit the current attached buffer to a SurfaceLayer.
-  void CommitSurfaceContents();
-
-  // Set TextureLayer contents to the current buffer.
-  void SetTextureLayerContents(ui::Layer* layer);
-
   // Set SurfaceLayer contents to the current buffer.
   void SetSurfaceLayerContents(ui::Layer* layer);
 
   // This returns true when the surface has some contents assigned to it.
   bool has_contents() const { return !!current_buffer_; }
 
-  // This is true if the buffer contents should be put in a SurfaceLayer
-  // rather than a TextureLayer.
-  static bool use_surface_layer_;
-
   // This window has the layer which contains the Surface contents.
   std::unique_ptr<aura::Window> window_;
 
   // This is true if it's possible that the layer properties (size, opacity,
   // etc.) may have been modified since the last commit. Attaching a new
   // buffer with the same size as the old shouldn't set this to true.
   bool has_pending_layer_changes_ = true;
 
   // This is true if the next commit to this surface should put its contents
   // into a new cc::SurfaceId. This allows for synchronization between Surface
@@ skipping 50 matching lines @@
   cc::TransferableResource current_resource_;
 
   // This is true if a call to Commit() as been made but
   // CommitSurfaceHierarchy() has not yet been called.
   bool needs_commit_surface_hierarchy_;
 
   // This is set when the compositing starts and passed to active frame
   // callbacks when compositing successfully ends.
   base::TimeTicks last_compositing_start_time_;
 
-  // This is true when the contents of the surface should be updated next time
-  // the compositor successfully ends compositing.
-  bool update_contents_after_successful_compositing_;
-
-  // The compsitor being observer or null if not observing a compositor.
-  ui::Compositor* compositor_;
-
   // Cursor providers. Surface does not own the cursor providers.
   std::set<CursorProvider*> cursor_providers_;
 
-  // Texture size.
-  gfx::Size texture_size_in_dip_;
-
   // This can be set to have some functions delegated. E.g. ShellSurface class
   // can set this to handle Commit() and apply any double buffered state it
   // maintains.
   SurfaceDelegate* delegate_;
 
   // 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_