remove linked_ptr from gpu/

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 
 #include <algorithm>
 #include <cmath>
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
-#include "base/memory/linked_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/debug_marker_manager.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ skipping 481 matching lines @@
   }
 
  private:
   GLES2DecoderImpl* decoder_;
   GLuint id_;
   DISALLOW_COPY_AND_ASSIGN(BackFramebuffer);
 };
 
 struct FenceCallback {
   FenceCallback() : fence(gl::GLFence::Create()) { DCHECK(fence); }
+  FenceCallback(FenceCallback&&) = default;
+  FenceCallback& operator=(FenceCallback&&) = default;
   std::vector<base::Closure> callbacks;
   std::unique_ptr<gl::GLFence> fence;
 };
 
 // }  // anonymous namespace.
 
 // static
 const unsigned int GLES2Decoder::kDefaultStencilMask =
     static_cast<unsigned int>(-1);
 
@@ skipping 1704 matching lines @@
   DecoderTextureState texture_state_;
   DecoderFramebufferState framebuffer_state_;
 
   std::unique_ptr<GPUTracer> gpu_tracer_;
   std::unique_ptr<GPUStateTracer> gpu_state_tracer_;
   const unsigned char* gpu_decoder_category_;
   int gpu_trace_level_;
   bool gpu_trace_commands_;
   bool gpu_debug_commands_;
 
-  std::queue<linked_ptr<FenceCallback> > pending_readpixel_fences_;
+  std::queue<FenceCallback> pending_readpixel_fences_;
 
   // After a second fence is inserted, both the GpuChannelMessageQueue and
   // CommandExecutor are descheduled. Once the first fence has completed, both
   // get rescheduled.
   std::vector<std::unique_ptr<gl::GLFence>> deschedule_until_finished_fences_;
 
   // Used to validate multisample renderbuffers if needed
   GLuint validation_texture_;
   GLuint validation_fbo_multisample_;
   GLuint validation_fbo_;
@@ skipping 8254 matching lines @@
       // For ANGLE client version 2, GL_STREAM_READ is not available.
       const GLenum usage_hint = feature_info_->gl_version_info().is_angle ?
           GL_STATIC_DRAW : GL_STREAM_READ;
       glBufferData(GL_PIXEL_PACK_BUFFER_ARB, pixels_size, NULL, usage_hint);
       GLenum error = glGetError();
       if (error == GL_NO_ERROR) {
         // No need to worry about ES3 pixel pack parameters, because no
         // PIXEL_PACK_BUFFER is bound, and all these settings haven't been
         // sent to GL.
         glReadPixels(x, y, width, height, format, type, 0);
-        pending_readpixel_fences_.push(linked_ptr<FenceCallback>(
-            new FenceCallback()));
+        pending_readpixel_fences_.push(FenceCallback());
         WaitForReadPixels(base::Bind(&GLES2DecoderImpl::FinishReadPixels,
                                      base::AsWeakPtr(this), c, buffer));
         glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, 0);
         return error::kNoError;
       } else {
         // On error, unbind pack buffer and fall through to sync readpixels
         glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, 0);
         glDeleteBuffersARB(1, &buffer);
       }
     }
@@ skipping 3829 matching lines @@
   if (!query_manager_.get())
     return;
   if (!query_manager_->ProcessPendingQueries(did_finish))
     current_decoder_error_ = error::kOutOfBounds;
 }
 
 // Note that if there are no pending readpixels right now,
 // this function will call the callback immediately.
 void GLES2DecoderImpl::WaitForReadPixels(base::Closure callback) {
   if (features().use_async_readpixels && !pending_readpixel_fences_.empty()) {
-    pending_readpixel_fences_.back()->callbacks.push_back(callback);
+    pending_readpixel_fences_.back().callbacks.push_back(callback);
   } else {
     callback.Run();
   }
 }
 
 void GLES2DecoderImpl::ProcessPendingReadPixels(bool did_finish) {
   // Note: |did_finish| guarantees that the GPU has passed the fence but
   // we cannot assume that GLFence::HasCompleted() will return true yet as
   // that's not guaranteed by all GLFence implementations.
   while (!pending_readpixel_fences_.empty() &&
          (did_finish ||
-          pending_readpixel_fences_.front()->fence->HasCompleted())) {
+          pending_readpixel_fences_.front().fence->HasCompleted())) {
     std::vector<base::Closure> callbacks =
-        pending_readpixel_fences_.front()->callbacks;
+        std::move(pending_readpixel_fences_.front().callbacks);
     pending_readpixel_fences_.pop();
     for (size_t i = 0; i < callbacks.size(); i++) {
       callbacks[i].Run();
     }
   }
 }
 
 void GLES2DecoderImpl::ProcessDescheduleUntilFinished() {
   if (deschedule_until_finished_fences_.size() < 2)
     return;
@@ skipping 3056 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu