Add commands Jump, Call and Return...

gpu/command_buffer/client/cmd_buffer_helper.cc

 // Copyright (c) 2009 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.
 
 // This file contains the implementation of the command buffer helper class.
 
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 
 namespace gpu {
@@ skipping 44 matching lines @@
 }
 
 // Inserts a new token into the command stream. It uses an increasing value
 // scheme so that we don't lose tokens (a token has passed if the current token
 // value is higher than that token). Calls Finish() if the token value wraps,
 // which will be rare.
 int32 CommandBufferHelper::InsertToken() {
   // Increment token as 31-bit integer. Negative values are used to signal an
   // error.
   token_ = (token_ + 1) & 0x7FFFFFFF;
-  CommandBufferEntry args;
-  args.value_uint32 = token_;
-  const uint32 kSetToken = 1;  // TODO(gman): add a common set of commands.
-  AddCommand(kSetToken, 1, &args);
+  cmd::SetToken& cmd = GetCmdSpace<cmd::SetToken>();
+  cmd.Init(token_);
   if (token_ == 0) {
     // we wrapped
     Finish();
     last_token_read_ = command_buffer_->GetToken();
     DCHECK_EQ(token_, last_token_read_);
   }
   return token_;
 }
 
 // Waits until the current token value is greater or equal to the value passed
@@ skipping 32 matching lines @@
     // but we need to make sure get wraps first, actually that get is 1 or
     // more (since put will wrap to 0 after we add the noops).
     DCHECK_LE(1, put_);
     Flush();
     while (get_ > put_ || get_ == 0) {
       // Do not loop forever if the flush fails, meaning the command buffer
       // reader has shutdown.
       if (!Flush())
         return;
     }
-    // Add the noops. By convention, a noop is a command 0 with no args.
-    // TODO(apatrick): A noop can have a size. It would be better to add a
-    //    single noop with a variable size. Watch out for size limit on
-    //    individual commands.
-    CommandHeader header;
-    header.size = 1;
-    header.command = 0;
-    while (put_ < entry_count_) {
-      entries_[put_++].value_header = header;
+    // Insert Noops to fill out buffer.
+    int32 num_entries = entry_count_ - put_;
+    while (num_entries > 0) {
+      int32 num_to_skip = std::min(CommandHeader::kMaxSize, num_entries);
+      cmd::Noop::Set(&entries_[put_], num_to_skip);
+      put_ += num_to_skip;
+      num_entries -= num_to_skip;
     }
     put_ = 0;
   }
   // If we have enough room, return immediatly.
   if (count <= AvailableEntries()) return;
   // Otherwise flush, and wait until we do have enough room.
   Flush();
   while (AvailableEntries() < count) {
     // Do not loop forever if the flush fails, meaning the command buffer reader
     // has shutdown.
     if (!Flush())
       return;
   }
 }
 
 CommandBufferEntry* CommandBufferHelper::GetSpace(uint32 entries) {
   WaitForAvailableEntries(entries);
   CommandBufferEntry* space = &entries_[put_];
   put_ += entries;
   return space;
 }
 
 parse_error::ParseError CommandBufferHelper::GetParseError() {
   int32 parse_error = command_buffer_->ResetParseError();
   return static_cast<parse_error::ParseError>(parse_error);
 }
 
 }  // namespace gpu