exo: Remove TextureLayer implementation of Surface.

components/exo/surface.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/exo/surface.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 172 matching lines @@
 void SurfaceFactoryOwner::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // Surface, public:
 
 Surface::Surface()
     : window_(new aura::Window(new CustomWindowDelegate(this))),
       has_pending_contents_(false),
       needs_commit_surface_hierarchy_(false),
-      update_contents_after_successful_compositing_(false),
-      compositor_(nullptr),
       delegate_(nullptr) {
   window_->SetType(ui::wm::WINDOW_TYPE_CONTROL);
   window_->SetName("ExoSurface");
   window_->SetProperty(kSurfaceKey, this);
   window_->Init(ui::LAYER_SOLID_COLOR);
   window_->set_layer_owner_delegate(this);
   window_->SetEventTargeter(base::WrapUnique(new CustomWindowTargeter));
   window_->set_owned_by_parent(false);
   surface_manager_ =
       aura::Env::GetInstance()->context_factory()->GetSurfaceManager();
-  if (use_surface_layer_) {
-    factory_owner_ = make_scoped_refptr(new SurfaceFactoryOwner);
-    factory_owner_->surface_ = this;
-    factory_owner_->id_allocator_ =
-        aura::Env::GetInstance()->context_factory()->CreateSurfaceIdAllocator();
-    factory_owner_->surface_factory_.reset(
-        new cc::SurfaceFactory(surface_manager_, factory_owner_.get()));
-  }
-
-  if (!factory_owner_) {
-    window_->AddObserver(this);
-  }
+  factory_owner_ = make_scoped_refptr(new SurfaceFactoryOwner);

[reveman, 2016/06/15 19:05:08]

nit: move to initializer list

+  factory_owner_->surface_ = this;
+  factory_owner_->id_allocator_ =
+      aura::Env::GetInstance()->context_factory()->CreateSurfaceIdAllocator();
+  factory_owner_->surface_factory_.reset(
+      new cc::SurfaceFactory(surface_manager_, factory_owner_.get()));
 }
 
 Surface::~Surface() {
   FOR_EACH_OBSERVER(SurfaceObserver, observers_, OnSurfaceDestroying(this));
 
   window_->layer()->SetShowSolidColorContent();
 
-  if (factory_owner_) {
-    factory_owner_->surface_ = nullptr;
-  } else {
-    window_->RemoveObserver(this);
-  }
-  if (compositor_)
-    compositor_->RemoveObserver(this);
+  factory_owner_->surface_ = nullptr;
 
   // Call pending frame callbacks with a null frame time to indicate that they
   // have been cancelled.
   frame_callbacks_.splice(frame_callbacks_.end(), pending_frame_callbacks_);
   active_frame_callbacks_.splice(active_frame_callbacks_.end(),
                                  frame_callbacks_);
   for (const auto& frame_callback : active_frame_callbacks_)
     frame_callback.Run(base::TimeTicks());
 
   if (!surface_id_.is_null())
     factory_owner_->surface_factory_->Destroy(surface_id_);
 }
 
 // static
 Surface* Surface::AsSurface(const aura::Window* window) {
   return window->GetProperty(kSurfaceKey);
 }
 
-// static
-void Surface::SetUseSurfaceLayer(bool use_surface_layer) {
-  use_surface_layer_ = use_surface_layer;
-}
-
 void Surface::Attach(Buffer* buffer) {
   TRACE_EVENT1("exo", "Surface::Attach", "buffer",
                buffer ? buffer->GetSize().ToString() : "null");
 
   has_pending_contents_ = true;
   pending_buffer_ = buffer ? buffer->AsWeakPtr() : base::WeakPtr<Buffer>();
 }
 
 void Surface::Damage(const gfx::Rect& damage) {
   TRACE_EVENT1("exo", "Surface::Damage", "damage", damage.ToString());
@@ skipping 181 matching lines @@
 }
 
 void Surface::CommitSurfaceHierarchy() {
   DCHECK(needs_commit_surface_hierarchy_);
   needs_commit_surface_hierarchy_ = false;
   has_pending_layer_changes_ = false;
 
   state_ = pending_state_;
   pending_state_.only_visible_on_secure_output = false;
 
-  if (factory_owner_) {
-    CommitSurfaceContents();
-  } else {
-    CommitTextureContents();
-  }
+  CommitSurfaceContents();

[reveman, 2016/06/15 19:05:08]

nit: can we just move the implementation of this function here again?

[reveman, 2016/06/15 19:05:08]

nit: can we just move the impl of CommitSurfaceContents back into this function
now?

 
   // Synchronize window hierarchy. This will position and update the stacking
   // order of all sub-surfaces after committing all pending state of sub-surface
   // descendants.
   aura::Window* stacking_target = nullptr;
   for (auto& sub_surface_entry : pending_sub_surfaces_) {
     Surface* sub_surface = sub_surface_entry.first;
 
     // Synchronsouly commit all pending state of the sub-surface and its
     // decendents.
@@ skipping 81 matching lines @@
 }
 
 std::unique_ptr<base::trace_event::TracedValue> Surface::AsTracedValue() const {
   std::unique_ptr<base::trace_event::TracedValue> value(
       new base::trace_event::TracedValue());
   value->SetString("name", window_->layer()->name());
   return value;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// aura::WindowObserver overrides:
-
-void Surface::OnWindowAddedToRootWindow(aura::Window* window) {
-  DCHECK(!compositor_);
-  DCHECK(!factory_owner_);
-  compositor_ = window_->layer()->GetCompositor();
-  compositor_->AddObserver(this);
-}
-
-void Surface::OnWindowRemovingFromRootWindow(aura::Window* window,
-                                             aura::Window* new_root) {
-  DCHECK(compositor_);
-  compositor_->RemoveObserver(this);
-  compositor_ = nullptr;
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // ui::LayerOwnerDelegate overrides:
 
 void Surface::OnLayerRecreated(ui::Layer* old_layer, ui::Layer* new_layer) {
   if (!current_buffer_)
     return;
 
   // TODO(reveman): Give the client a chance to provide new contents.
-  if (factory_owner_) {
-    SetSurfaceLayerContents(new_layer);
-  } else {
-    SetTextureLayerContents(new_layer);
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// ui::CompositorObserver overrides:
-
-void Surface::OnCompositingDidCommit(ui::Compositor* compositor) {
-  DCHECK(!factory_owner_);
-  // Move frame callbacks to the end of |active_frame_callbacks_|.
-  active_frame_callbacks_.splice(active_frame_callbacks_.end(),
-                                 frame_callbacks_);
-}
-
-void Surface::OnCompositingStarted(ui::Compositor* compositor,
-                                   base::TimeTicks start_time) {
-  last_compositing_start_time_ = start_time;
-}
-
-void Surface::OnCompositingEnded(ui::Compositor* compositor) {
-  // Run all frame callbacks associated with the compositor's active tree.
-  while (!active_frame_callbacks_.empty()) {
-    active_frame_callbacks_.front().Run(last_compositing_start_time_);
-    active_frame_callbacks_.pop_front();
-  }
-
-  // Nothing more to do in here unless this has been set.
-  if (!update_contents_after_successful_compositing_)
-    return;
-
-  update_contents_after_successful_compositing_ = false;
-
-  // Early out if no contents is currently assigned to the surface.
-  if (!current_buffer_)
-    return;
-
-  // Update contents by producing a new texture mailbox for the current buffer.

[reveman, 2016/06/15 19:05:09]

nit: this could was here to handle lost context situations and that's currently
missing for cc::surfaces. I don't think that should stop us from removing this
code but maybe we can add a TODO somewhere in this file that is about fixing
that.

-  SetTextureLayerContents(window_->layer());
-}
-
-void Surface::OnCompositingAborted(ui::Compositor* compositor) {
-  // The contents of this surface might be lost if compositing aborted because
-  // of a lost graphics context. We recover from this by updating the contents
-  // of the surface next time the compositor successfully ends compositing.
-  update_contents_after_successful_compositing_ = true;
-}
-
-void Surface::OnCompositingShuttingDown(ui::Compositor* compositor) {
-  compositor->RemoveObserver(this);
-  compositor_ = nullptr;
+  SetSurfaceLayerContents(new_layer);
 }
 
 void Surface::WillDraw(cc::SurfaceId id) {
   while (!active_frame_callbacks_.empty()) {
     active_frame_callbacks_.front().Run(base::TimeTicks::Now());
     active_frame_callbacks_.pop_front();
   }
 }
 
 void Surface::CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces() {
@@ skipping 24 matching lines @@
   return false;
 }
 
 void Surface::SetSurfaceHierarchyNeedsCommitToNewSurfaces() {
   needs_commit_to_new_surface_ = true;
   for (auto& sub_surface_entry : pending_sub_surfaces_) {
     sub_surface_entry.first->SetSurfaceHierarchyNeedsCommitToNewSurfaces();
   }
 }
 
-void Surface::CommitTextureContents() {
-  // We update contents if Attach() has been called since last commit.
-  if (has_pending_contents_) {
-    has_pending_contents_ = false;
-
-    current_buffer_ = pending_buffer_;
-    pending_buffer_.reset();
-
-    cc::TextureMailbox texture_mailbox;
-    std::unique_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback;
-    if (current_buffer_) {
-      texture_mailbox_release_callback = current_buffer_->ProduceTextureMailbox(
-          &texture_mailbox, state_.only_visible_on_secure_output,
-          true /* client_usage */);
-    }
-
-    // Update layer with the new contents.
-    if (texture_mailbox_release_callback) {
-      texture_size_in_dip_ = gfx::ScaleToFlooredSize(
-          texture_mailbox.size_in_pixels(), 1.0f / state_.buffer_scale);
-      window_->layer()->SetTextureMailbox(
-          texture_mailbox, std::move(texture_mailbox_release_callback),
-          texture_size_in_dip_);
-      window_->layer()->SetTextureFlipped(false);
-    } else {
-      // Show solid color content if no buffer is attached or we failed
-      // to produce a texture mailbox for the currently attached buffer.
-      window_->layer()->SetShowSolidColorContent();
-      window_->layer()->SetColor(SK_ColorBLACK);
-    }
-
-    // Schedule redraw of the damage region.
-    for (SkRegion::Iterator it(pending_damage_); !it.done(); it.next())
-      window_->layer()->SchedulePaint(gfx::SkIRectToRect(it.rect()));
-
-    // Reset damage.
-    pending_damage_.setEmpty();
-  }
-
-  if (window_->layer()->has_external_content()) {
-    // Determine the new surface size.
-    // - Texture size in DIP defines the size if nothing else is set.
-    // - If a viewport is set then that defines the size, otherwise
-    //   the crop rectangle defines the size if set.
-    gfx::Size contents_size = texture_size_in_dip_;
-    if (!state_.viewport.IsEmpty()) {
-      contents_size = state_.viewport;
-    } else if (!state_.crop.IsEmpty()) {
-      DLOG_IF(WARNING, !gfx::IsExpressibleAsInt(state_.crop.width()) ||
-                           !gfx::IsExpressibleAsInt(state_.crop.height()))
-          << "Crop rectangle size (" << state_.crop.size().ToString()
-          << ") most be expressible using integers when viewport is not set";
-      contents_size = gfx::ToCeiledSize(state_.crop.size());
-    }
-    window_->layer()->SetTextureCrop(state_.crop);
-    window_->layer()->SetTextureScale(
-        static_cast<float>(texture_size_in_dip_.width()) /
-            contents_size.width(),
-        static_cast<float>(texture_size_in_dip_.height()) /
-            contents_size.height());
-    window_->layer()->SetTextureAlpha(state_.alpha);
-    window_->layer()->SetBounds(
-        gfx::Rect(window_->layer()->bounds().origin(), contents_size));
-  }
-
-  // Move pending frame callbacks to the end of |frame_callbacks_|.
-  frame_callbacks_.splice(frame_callbacks_.end(), pending_frame_callbacks_);
-
-  // Update alpha compositing properties.
-  // TODO(reveman): Use a more reliable way to force blending off than setting
-  // fills-bounds-opaquely.
-  window_->layer()->SetFillsBoundsOpaquely(
-      state_.blend_mode == SkXfermode::kSrc_Mode ||
-      state_.opaque_region.contains(
-          gfx::RectToSkIRect(gfx::Rect(window_->layer()->size()))));
-}
-
 void Surface::CommitSurfaceContents() {
   // We update contents if Attach() has been called since last commit.
   if (has_pending_contents_) {
     has_pending_contents_ = false;
     current_buffer_ = pending_buffer_;
     pending_buffer_.reset();
 
     if (current_buffer_) {
       std::unique_ptr<cc::SingleReleaseCallback>
           texture_mailbox_release_callback;
@@ skipping 136 matching lines @@
   pending_damage_.setEmpty();
 
   DCHECK(!current_resource_.id ||
          factory_owner_->release_callbacks_.count(current_resource_.id));
 
   // Move pending frame callbacks to the end of active_frame_callbacks_
   active_frame_callbacks_.splice(active_frame_callbacks_.end(),
                                  pending_frame_callbacks_);
 }
 
-void Surface::SetTextureLayerContents(ui::Layer* layer) {
-  DCHECK(current_buffer_);
-
-  cc::TextureMailbox texture_mailbox;
-  std::unique_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback =
-      current_buffer_->ProduceTextureMailbox(
-          &texture_mailbox, state_.only_visible_on_secure_output,
-          false /* client_usage */);
-  if (!texture_mailbox_release_callback)
-    return;
-
-  layer->SetTextureMailbox(texture_mailbox,
-                           std::move(texture_mailbox_release_callback),
-                           texture_size_in_dip_);
-  layer->SetTextureFlipped(false);
-  layer->SetTextureCrop(state_.crop);
-  layer->SetTextureScale(static_cast<float>(texture_size_in_dip_.width()) /
-                             layer->bounds().width(),
-                         static_cast<float>(texture_size_in_dip_.height()) /
-                             layer->bounds().height());
-  layer->SetTextureAlpha(state_.alpha);
-}
-
 void Surface::SetSurfaceLayerContents(ui::Layer* layer) {
   if (surface_id_.is_null())
     return;
 
   gfx::Size layer_size = layer->bounds().size();
   float contents_surface_to_layer_scale = 1.0f;
 
   layer->SetShowSurface(
       surface_id_,
       base::Bind(&SatisfyCallback, base::Unretained(surface_manager_)),
       base::Bind(&RequireCallback, base::Unretained(surface_manager_)),
       layer_size, contents_surface_to_layer_scale, layer_size);
 }
 
-bool Surface::use_surface_layer_ = false;
-
 }  // namespace exo