exo: Add support for secure_output 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 106 matching lines @@
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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),
       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(make_scoped_ptr(new CustomWindowTargeter));
@@ skipping 151 matching lines @@
       sibling_it, pending_sub_surfaces_,
       FindListEntry(pending_sub_surfaces_, sub_surface));
 }
 
 void Surface::SetViewport(const gfx::Size& viewport) {
   TRACE_EVENT1("exo", "Surface::SetViewport", "viewport", viewport.ToString());
 
   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::Commit() {
   TRACE_EVENT0("exo", "Surface::Commit");
 
   needs_commit_surface_hierarchy_ = true;
 
   if (delegate_)
     delegate_->OnSurfaceCommit();
   else
     CommitSurfaceHierarchy();
 }
 
 void Surface::CommitSurfaceHierarchy() {
   DCHECK(needs_commit_surface_hierarchy_);
   needs_commit_surface_hierarchy_ = false;
 
   // 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();
 
+    // TODO(dcastagna): Make secure_output_only a layer property instead of a
+    // texture mailbox flag so this can be changed without have to provide
+    // new contents.
+    bool secure_output_only = pending_only_visible_on_secure_output_;
+    pending_only_visible_on_secure_output_ = false;
+
     cc::TextureMailbox texture_mailbox;
     scoped_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback;
     if (current_buffer_) {
-      texture_mailbox_release_callback =
-          current_buffer_->ProduceTextureMailbox(&texture_mailbox, false);
+      texture_mailbox_release_callback = current_buffer_->ProduceTextureMailbox(
+          &texture_mailbox, secure_output_only, false);
     }
 
     if (texture_mailbox_release_callback) {
       // Update layer with the new contents. If a viewport has been set then
       // use that to determine the size of the layer and the surface, otherwise
       // buffer scale and buffer size determines the size.
       gfx::Size contents_size =
           pending_viewport_.IsEmpty()
               ? gfx::ScaleToFlooredSize(texture_mailbox.size_in_pixels(),
                                         1.0f / pending_buffer_scale_)
@@ skipping 155 matching lines @@
   // 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;
 
+  // TODO(dcastagna): Make secure_output_only a layer property instead of a
+  // texture mailbox flag.
+  bool secure_output_only = false;
+
   // Update contents by producing a new texture mailbox for the current buffer.
   cc::TextureMailbox texture_mailbox;
   scoped_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback =
-      current_buffer_->ProduceTextureMailbox(&texture_mailbox, true);
+      current_buffer_->ProduceTextureMailbox(&texture_mailbox,
+                                             secure_output_only, true);
   if (texture_mailbox_release_callback) {
     layer()->SetTextureMailbox(texture_mailbox,
                                std::move(texture_mailbox_release_callback),
                                layer()->bounds().size());
     layer()->SetTextureFlipped(false);
     layer()->SchedulePaint(gfx::Rect(texture_mailbox.size_in_pixels()));
   }
 }
 
 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;
 }
 
 }  // namespace exo