Use local ids for Surfaces APIs that can only apply to local surfaces

examples/ganesh_app/texture_uploader.cc

 // Copyright 2014 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 "examples/ganesh_app/texture_uploader.h"
 
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES
 #endif
 
 #include "base/bind.h"
 #include "gpu/GLES2/gl2chromium.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "mojo/public/c/gles2/gles2.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
 #include "mojo/services/geometry/public/cpp/geometry_util.h"
 #include "mojo/services/surfaces/public/cpp/surfaces_utils.h"
 
 namespace examples {
 
 TextureUploader::Client::~Client() {
 }
 
 TextureUploader::TextureUploader(Client* client,
                                  mojo::Shell* shell,
                                  base::WeakPtr<mojo::GLContext> context)
     : client_(client),
       context_(context),
-      next_resource_id_(0),
-      id_namespace_(0),
+      next_resource_id_(0u),
+      id_namespace_(0u),
+      local_id_(0u),
       weak_factory_(this) {
   context_->AddObserver(this);
 
   mojo::ServiceProviderPtr surfaces_service_provider;
   shell->ConnectToApplication("mojo:surfaces_service",
                               mojo::GetProxy(&surfaces_service_provider));
-  mojo::ConnectToService(surfaces_service_provider.get(), &surfaces_service_);
-
-  surfaces_service_->CreateSurfaceConnection(
-      base::Bind(&TextureUploader::OnSurfaceConnectionCreated,
-                 weak_factory_.GetWeakPtr()));
+  mojo::ConnectToService(surfaces_service_provider.get(), &surface_);
+  surface_.set_client(this);
 }
 
 TextureUploader::~TextureUploader() {
-  if (surface_id_)
-    surface_->DestroySurface(surface_id_.Clone());
+  if (local_id_ != 0u)
+    surface_->DestroySurface(local_id_);

[sky, 2015/01/13 18:14:27]

As the pipe is destroyed in the destructor is this call strictly necessary?

[jamesr, 2015/01/14 01:50:29]

It's not, closing the pipe destroys all associated surfaces.  Removed.

   if (context_.get())
     context_->RemoveObserver(this);
 }
 
 void TextureUploader::Upload(scoped_ptr<mojo::GLTexture> texture) {
   if (!surface_) {
     pending_upload_ = texture.Pass();
     return;
   }
 
@@ skipping 56 matching lines @@
   texture_state->background_color->rgba = 0;
   for (int i = 0; i < 4; ++i)
     texture_state->vertex_opacity.push_back(1.f);
   texture_state->flipped = false;
 
   frame->resources.push_back(resource.Pass());
   quad->texture_quad_state = texture_state.Pass();
   pass->quads.push_back(quad.Pass());
 
   frame->passes.push_back(pass.Pass());
-  surface_->SubmitFrame(surface_id_.Clone(), frame.Pass(), mojo::Closure());
+  surface_->SubmitFrame(local_id_, frame.Pass(), mojo::Closure());
 }
 
 void TextureUploader::EnsureSurfaceForSize(const mojo::Size& size) {
-  if (surface_id_ && size == surface_size_)
+  if (local_id_ != 0u && size == surface_size_)
     return;
 
-  if (surface_id_) {
-    surface_->DestroySurface(surface_id_.Clone());
-  } else {
-    surface_id_ = mojo::SurfaceId::New();
-    surface_id_->id_namespace = id_namespace_;
+  if (local_id_ != 0u) {
+    surface_->DestroySurface(local_id_);
   }
 
-  surface_id_->local++;
-  surface_->CreateSurface(surface_id_.Clone());
-  client_->OnSurfaceIdAvailable(surface_id_.Clone());
+  local_id_++;
+  surface_->CreateSurface(local_id_);
   surface_size_ = size;
+  if (id_namespace_ != 0u)
+    SendFullyQualifiedID();
+}
+void TextureUploader::SendFullyQualifiedID() {
+  auto qualified_id = mojo::SurfaceId::New();
+  qualified_id->id_namespace = id_namespace_;
+  qualified_id->local = local_id_;
+  client_->OnSurfaceIdAvailable(qualified_id.Pass());
 }
 
 void TextureUploader::OnContextLost() {
   LOG(FATAL) << "Context lost.";
 }
 
 void TextureUploader::SetIdNamespace(uint32_t id_namespace) {
+  id_namespace_ = id_namespace;
+  if (local_id_ != 0u)
+    SendFullyQualifiedID();
 }
 
 void TextureUploader::ReturnResources(
     mojo::Array<mojo::ReturnedResourcePtr> resources) {
   if (!resources.size())
     return;
   context_->MakeCurrent();
   for (size_t i = 0u; i < resources.size(); ++i) {
     mojo::ReturnedResourcePtr resource = resources[i].Pass();
     DCHECK_EQ(1, resource->count);
     glWaitSyncPointCHROMIUM(resource->sync_point);
     mojo::GLTexture* texture = resource_to_texture_map_[resource->id];
     DCHECK_NE(0u, texture->texture_id());
     resource_to_texture_map_.erase(resource->id);
     delete texture;
   }
 }
 
-void TextureUploader::OnSurfaceConnectionCreated(mojo::SurfacePtr surface,
-                                                 uint32_t id_namespace) {
-  surface_ = surface.Pass();
-  surface_.set_client(this);
-  id_namespace_ = id_namespace;
-
-  if (pending_upload_)
-    Upload(pending_upload_.Pass());
-}
-
 }  // namespace examples