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

examples/bitmap_uploader/bitmap_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/bitmap_uploader/bitmap_uploader.h"
 
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES
 #endif  // GL_GLEXT_PROTOTYPES
 
@@ skipping 20 matching lines @@
 
 }
 
 BitmapUploader::BitmapUploader(View* view)
     : view_(view),
       color_(TRANSPARENT_COLOR),
       width_(0),
       height_(0),
       format_(BGRA),
       next_resource_id_(1u),
-      id_namespace_(0),
-      weak_factory_(this) {
+      id_namespace_(0u),
+      local_id_(0u) {
 }
 
 void BitmapUploader::Init(Shell* shell) {
   ServiceProviderPtr surfaces_service_provider;
   shell->ConnectToApplication("mojo:surfaces_service",
                               GetProxy(&surfaces_service_provider));
-  ConnectToService(surfaces_service_provider.get(), &surfaces_service_);
+  ConnectToService(surfaces_service_provider.get(), &surface_);
+  surface_.set_client(this);
+
   ServiceProviderPtr gpu_service_provider;
   shell->ConnectToApplication("mojo:native_viewport_service",
                               GetProxy(&gpu_service_provider));
   ConnectToService(gpu_service_provider.get(), &gpu_service_);
 
-  surfaces_service_->CreateSurfaceConnection(base::Bind(
-      &BitmapUploader::OnSurfaceConnectionCreated, weak_factory_.GetWeakPtr()));
   CommandBufferPtr gles2_client;
   gpu_service_->CreateOffscreenGLES2Context(GetProxy(&gles2_client));
   gles2_context_ =
       MojoGLES2CreateContext(gles2_client.PassMessagePipe().release().value(),
                              &LostContext,
                              NULL,
                              Environment::GetDefaultAsyncWaiter());
   MojoGLES2MakeCurrent(gles2_context_);
 }
 
@@ skipping 22 matching lines @@
 }
 
 void BitmapUploader::Upload() {
   Size size;
   size.width = view_->bounds().width;
   size.height = view_->bounds().height;
   if (!size.width || !size.height) {
     view_->SetSurfaceId(SurfaceId::New());
     return;
   }
-  if (!surface_)  // Can't upload yet, store for later.
+  if (id_namespace_ == 0u)  // Can't generate a qualified ID yet.
     return;
-  if (!surface_id_ || size != surface_size_) {
-    if (surface_id_) {
-      surface_->DestroySurface(surface_id_.Clone());
-    } else {
-      surface_id_ = SurfaceId::New();
-      surface_id_->id_namespace = id_namespace_;
+
+  if (size != surface_size_) {
+    if (local_id_ != 0u) {
+      surface_->DestroySurface(local_id_);
     }
-    surface_id_->local++;
-    surface_->CreateSurface(surface_id_.Clone());
-    view_->SetSurfaceId(surface_id_.Clone());
+    local_id_++;
+    surface_->CreateSurface(local_id_);
     surface_size_ = size;
+    auto qualified_id = SurfaceId::New();
+    qualified_id->id_namespace = id_namespace_;
+    qualified_id->local = local_id_;
+    view_->SetSurfaceId(qualified_id.Pass());
   }
 
   Rect bounds;
   bounds.width = size.width;
   bounds.height = size.height;
   PassPtr pass = CreateDefaultPass(1, bounds);
   FramePtr frame = Frame::New();
   frame->resources.resize(0u);
 
   pass->quads.resize(0u);
@@ skipping 93 matching lines @@
     color_state->color = Color::New();
     color_state->color->rgba = color_;
     color_state->force_anti_aliasing_off = false;
 
     quad->solid_color_quad_state = color_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 BitmapUploader::SetIdNamespace(uint32_t id_namespace) {
+  id_namespace_ = id_namespace;
+  if (color_ != TRANSPARENT_COLOR || bitmap_.get())
+    Upload();
 }
 
 void BitmapUploader::ReturnResources(Array<ReturnedResourcePtr> resources) {
   if (!resources.size())
     return;
   MojoGLES2MakeCurrent(gles2_context_);
   // TODO(jamesr): Recycle.
   for (size_t i = 0; i < resources.size(); ++i) {
     ReturnedResourcePtr resource = resources[i].Pass();
     DCHECK_EQ(1, resource->count);
     glWaitSyncPointCHROMIUM(resource->sync_point);
     uint32_t texture_id = resource_to_texture_id_map_[resource->id];
     DCHECK_NE(0u, texture_id);
     resource_to_texture_id_map_.erase(resource->id);
     glDeleteTextures(1, &texture_id);
   }
 }
 
-void BitmapUploader::OnSurfaceConnectionCreated(SurfacePtr surface,
-                                                uint32_t id_namespace) {
-  surface_ = surface.Pass();
-  surface_.set_client(this);
-  id_namespace_ = id_namespace;
-  if (color_ != TRANSPARENT_COLOR || bitmap_.get())
-    Upload();
-}
-
 uint32_t BitmapUploader::BindTextureForSize(const Size size) {
   // TODO(jamesr): Recycle textures.
   GLuint texture = 0u;
   glGenTextures(1, &texture);
   glBindTexture(GL_TEXTURE_2D, texture);
   glTexImage2D(GL_TEXTURE_2D,
                0,
                TextureFormat(),
                size.width,
                size.height,
                0,
                TextureFormat(),
                GL_UNSIGNED_BYTE,
                0);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   return texture;
 }
 
 uint32_t BitmapUploader::TextureFormat() {
   return format_ == BGRA ? GL_BGRA_EXT : GL_RGBA;
 }
 
 }  // namespace mojo