gpu: Add async pixel transfer interface, stub and tests.

gpu/command_buffer/service/texture_manager.cc

 // Copyright (c) 2012 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 "gpu/command_buffer/service/texture_manager.h"
 #include "base/bits.h"
 #include "base/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
@@ skipping 1186 matching lines @@
 }
 
 void TextureManager::AddToSignature(
     TextureInfo* info,
     GLenum target,
     GLint level,
     std::string* signature) const {
   info->AddToSignature(feature_info_.get(), target, level, signature);
 }
 
+void TextureManager::AddPendingAsyncPixelTransfer(
+    base::WeakPtr<gfx::AsyncPixelTransferState> state, TextureInfo* info) {
+  pending_async_transfers_.push_back(PendingAsyncTransfer(state,info));
+}
+
+void TextureManager::BindFinishedAsyncPixelTransfers(
+    bool* texture_dirty, bool* framebuffer_dirty) {
+  DCHECK(texture_dirty);

[greggman, 2012/12/14 06:08:06]

If this is going to be called often (like from DoCommand) then maybe you need 2
lists or something that makes it exit quicker if there is nothing to be done? Or
maybe I'm over thinking it. Ideally if there's several pending textures but none
of them are ready then this should exit extremely quickly.

[epenner, 2012/12/14 21:01:34]

It doesn't need to happen in DoCommand IMO. Only once per flush. But the loop
can also terminate early since the uploads occur in order. So it's now only one
iteration per completed upload.

+  DCHECK(framebuffer_dirty);
+  *texture_dirty = false;
+  *framebuffer_dirty = false;
+
+  // Remove finished transfers from the list, while
+  // marking whether the texture unit or frame_buffer is dirty.
+  for (PendingAsyncTransferList::iterator it = pending_async_transfers_.begin();
+      it != pending_async_transfers_.end();
+      it++) {

[greggman, 2012/12/14 06:08:06]

always pre-increment stl iterators no?

   ++it means it = it + 1
   it++ means temp = it; it = it + 1; return temp

for a complex iterator making that temp can be expensive. I don't know if
stl::list::iterator is complex. I'm guessing stl::map::iterator and
stl::unordered_map::iterator are complex

[epenner, 2012/12/14 21:01:34]

Done.

+    // The AsyncState is owned by the TextureInfo. So if the
+    // async state is deleted, so is the TextureInfo.
+    if (!it->first.get()) {
+      pending_async_transfers_.erase(it++);

[greggman, 2012/12/14 06:08:06]

I don't think you can call erase in stl like this in a loop can you? I thought
the correct way was

   for (it = list.begin; it != list.end;) {
     if (want to erase) {
       it = list.erase(it);
     } else {
       ++it;
     }
   }

[epenner, 2012/12/14 21:01:34]

Sorry, last minute change from remove_if(). Done.

+      continue;
+    }
+    // If the transfer is finished, bind it to the texture,
+    // and update the TextureInfo.
+    if (!it->first->TransferIsInProgress()) {
+      // Set the dirty status.
+      *texture_dirty = true;
+      *framebuffer_dirty |= it->second->IsAttachedToFramebuffer();
+      gfx::AsyncTexImage2DParams tex_define_params;
+      it->second->GetAsyncTransferState()->BindTransfer(&tex_define_params);
+      SetLevelInfo(
+          it->second,
+          tex_define_params.target,
+          tex_define_params.level,
+          tex_define_params.internal_format,
+          tex_define_params.width,
+          tex_define_params.height,
+          1, // depth
+          tex_define_params.border,
+          tex_define_params.format,
+          tex_define_params.type,
+          true); // cleared
+      pending_async_transfers_.erase(it++);

[greggman, 2012/12/14 06:08:06]

Same as above. Besides this would skip the element after the one erased no?

[epenner, 2012/12/14 21:01:34]

See above. Done.

+      continue;
+    }
+  }
+}
+
 }  // namespace gles2
 }  // namespace gpu