Give base::SharedMemory::CreateAnonymous an executable flag

gpu/command_buffer/service/command_buffer_service.cc

 // Copyright (c) 2011 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/command_buffer_service.h"
 
 #include <limits>
 
 #include "base/callback.h"
 #include "base/process_util.h"
@@ skipping 31 matching lines @@
   }
 
   if (size <= 0 || size > kMaxCommandBufferSize) {
     LOG(ERROR) << "Failed because command buffer size was invalid.";
     return false;
   }
 
   num_entries_ = size / sizeof(CommandBufferEntry);
 
   SharedMemory shared_memory;
-  if (!shared_memory.CreateAnonymous(size)) {
+  if (!shared_memory.CreateAnonymous(size, false)) {
     LOG(ERROR) << "Failed to create shared memory for command buffer.";
     return true;
   }
 
   return Initialize(&shared_memory, size);
 }
 
 bool CommandBufferService::Initialize(base::SharedMemory* buffer, int32 size) {
   // Fail if already initialized.
   if (ring_buffer_.shared_memory) {
@@ skipping 75 matching lines @@
 }
 
 void CommandBufferService::SetGetOffset(int32 get_offset) {
   DCHECK(get_offset >= 0 && get_offset < num_entries_);
   get_offset_ = get_offset;
 }
 
 int32 CommandBufferService::CreateTransferBuffer(size_t size,
                                                  int32 id_request) {
   SharedMemory buffer;
-  if (!buffer.CreateAnonymous(size))
+  if (!buffer.CreateAnonymous(size, false))
     return -1;
 
   return RegisterTransferBuffer(&buffer, size, id_request);
 }
 
 int32 CommandBufferService::RegisterTransferBuffer(
     base::SharedMemory* shared_memory, size_t size, int32 id_request) {
   // Check we haven't exceeded the range that fits in a 32-bit integer.
   if (unused_registered_object_elements_.empty()) {
     if (registered_objects_.size() > std::numeric_limits<uint32>::max())
@@ skipping 109 matching lines @@
     Callback0::Type* callback) {
   put_offset_change_callback_.reset(callback);
 }
 
 void CommandBufferService::SetParseErrorCallback(
     Callback0::Type* callback) {
   parse_error_callback_.reset(callback);
 }
 
 }  // namespace gpu