exo: Add support for alpha_compositing interface to wayland bindings.

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 118 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // Surface, public:
 
 Surface::Surface()
     : aura::Window(new CustomWindowDelegate(this)),
       has_pending_contents_(false),
       pending_input_region_(SkIRect::MakeLargest()),
       pending_buffer_scale_(1.0f),
       pending_only_visible_on_secure_output_(false),
+      pending_blend_mode_(SkXfermode::kSrcOver_Mode),
+      pending_alpha_(1.0f),
       input_region_(SkIRect::MakeLargest()),
       needs_commit_surface_hierarchy_(false),
       update_contents_after_successful_compositing_(false),
       compositor_(nullptr),
       delegate_(nullptr) {
   SetType(ui::wm::WINDOW_TYPE_CONTROL);
   SetName("ExoSurface");
   SetProperty(kSurfaceKey, this);
   Init(ui::LAYER_SOLID_COLOR);
   SetEventTargeter(base::WrapUnique(new CustomWindowTargeter));
@@ skipping 158 matching lines @@
   pending_viewport_ = viewport;
 }
 
 void Surface::SetOnlyVisibleOnSecureOutput(bool only_visible_on_secure_output) {
   TRACE_EVENT1("exo", "Surface::SetOnlyVisibleOnSecureOutput",
                "only_visible_on_secure_output", only_visible_on_secure_output);
 
   pending_only_visible_on_secure_output_ = only_visible_on_secure_output;
 }
 
+void Surface::SetBlendMode(SkXfermode::Mode blend_mode) {
+  TRACE_EVENT1("exo", "Surface::SetBlendMode", "blend_mode", blend_mode);
+
+  pending_blend_mode_ = blend_mode;
+}
+
+void Surface::SetAlpha(float alpha) {
+  TRACE_EVENT1("exo", "Surface::SetAlpha", "alpha", alpha);
+
+  pending_alpha_ = alpha;
+}
+
 void Surface::Commit() {
   TRACE_EVENT0("exo", "Surface::Commit");
 
   needs_commit_surface_hierarchy_ = true;
 
   if (delegate_)
     delegate_->OnSurfaceCommit();
   else
     CommitSurfaceHierarchy();
 }
@@ skipping 29 matching lines @@
       gfx::Size contents_size =
           pending_viewport_.IsEmpty()
               ? gfx::ScaleToFlooredSize(texture_mailbox.size_in_pixels(),
                                         1.0f / pending_buffer_scale_)
               : pending_viewport_;
       layer()->SetTextureMailbox(texture_mailbox,
                                  std::move(texture_mailbox_release_callback),
                                  contents_size);
       layer()->SetTextureFlipped(false);
       layer()->SetBounds(gfx::Rect(layer()->bounds().origin(), contents_size));
-      layer()->SetFillsBoundsOpaquely(pending_opaque_region_.contains(
-          gfx::RectToSkIRect(gfx::Rect(contents_size))));
     } else {
       // Show solid color content if no buffer is attached or we failed
       // to produce a texture mailbox for the currently attached buffer.
       layer()->SetShowSolidColorContent();
       layer()->SetColor(SK_ColorBLACK);
     }
 
     // Schedule redraw of the damage region.
     for (SkRegion::Iterator it(pending_damage_); !it.done(); it.next())
       layer()->SchedulePaint(gfx::SkIRectToRect(it.rect()));
 
     // Reset damage.
     pending_damage_.setEmpty();
   }
 
   // Update current input region.
   input_region_ = pending_input_region_;
 
   // 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.
+  layer()->SetFillsBoundsOpaquely(
+      pending_blend_mode_ == SkXfermode::kSrc_Mode ||
+      pending_opaque_region_.contains(
+          gfx::RectToSkIRect(gfx::Rect(layer()->size()))));
+  if (layer()->has_external_content())
+    layer()->SetTextureAlpha(pending_alpha_);
+
   // 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.
     if (sub_surface->needs_commit_surface_hierarchy())
@@ skipping 144 matching lines @@
   // 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;
 }
 
 }  // namespace exo