Rename UploadToVideoFrame to ConvertToVideoFrame.

chrome/renderer/media/gles2_video_decode_context.h

 // Copyright (c) 2010 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.
 
 #ifndef CHROME_RENDERER_MEDIA_GLES2_VIDEO_DECODE_CONTEXT_H_
 #define CHROME_RENDERER_MEDIA_GLES2_VIDEO_DECODE_CONTEXT_H_
 
 #include <vector>
 
 #include "media/video/video_decode_context.h"
@@ skipping 19 matching lines @@
 // 1. Memory mapped textures (aka software decoding mode).
 //    Each texture is memory mapped and appears to the VideoDecodeEngine as
 //    system memory.
 //
 //    The usage of the textures is that the VideoDecodeEngine is performing
 //    software video decoding and use them as if they are allocated in plain
 //    system memory (in fact they are allocated in system memory and shared
 //    bwith the GPU process). An additional step of uploading the content to
 //    video memory is needed. Since VideoDecodeEngine is unaware of the video
 //    memory, this upload operation is performed by calling
-//    UploadToVideoFrame().
+//    ConvertToVideoFrame().
 //
 //    After the content is uploaded to video memory, WebKit will see the video
 //    frame as textures and will perform the necessary operations for
 //    rendering.
 //
 // 2. Opaque textures (aka hardware decoding mode).
 //    In this mode of operation each video frame is backed by some opaque
 //    textures. This is used only when hardware video decoding is used. The
 //    textures needs to be generated and allocated inside the renderer process
 //    first. This will establish a translation between texture ID in the
@@ skipping 28 matching lines @@
                           bool memory_mapped, ggl::Context* context);
   virtual ~Gles2VideoDecodeContext();
 
   // media::VideoDecodeContext implementation.
   virtual void* GetDevice();
   virtual void AllocateVideoFrames(
       int frames_num, size_t width, size_t height,
       media::VideoFrame::Format format,
       std::vector<scoped_refptr<media::VideoFrame> >* frames_out, Task* task);
   virtual void ReleaseAllVideoFrames();
-  virtual void UploadToVideoFrame(void* buffer,
-                                  scoped_refptr<media::VideoFrame> frame,
-                                  Task* task);
+  virtual void ConvertToVideoFrame(void* buffer,
+                                   scoped_refptr<media::VideoFrame> frame,
+                                   Task* task);
   virtual void Destroy(Task* task);
 
   // Accessor of the current mode of this decode context.
   bool IsMemoryMapped() const { return memory_mapped_; }
 
  private:
   // Message loop for Render Thread.
   MessageLoop* message_loop_;
 
   // Type of storage provided by this class.
   bool memory_mapped_;
 
   // Pointer to the GLES2 context.
   ggl::Context* context_;
 
   // VideoFrames allocated.
   std::vector<scoped_refptr<media::VideoFrame> > frames_;
 
   DISALLOW_COPY_AND_ASSIGN(Gles2VideoDecodeContext);
 };
 
 #endif  // CHROME_RENDERER_MEDIA_GLES2_VIDEO_DECODE_CONTEXT_H_