Chromium為視頻標簽(video)渲染視頻畫面的過程分析

StreamTextureProxyImpl類的成員函數BindToLoop首先將參數client指向的VideoFrameProviderClientImpl對象保存在成員變量client_中，以便以後可以將MediaPlayer的解碼輸出交給它處理。

另外一個參數loop描述的是Render進程的Compoisitor線程的消息隊列。StreamTextureProxyImpl類的成員函數BindToLoop接下來判斷當前正在執行的線程是否就是Compositor線程。如果是的話，那麼就直接調用另外一個成員函數BindToThread，用來在Compositor線程中設置一個Route，接收MediaPlayer的解碼輸出通知。如果不是的話，那麼就需要向Compositor線程的消息隊列發送一個Task。當這個Task在Compositor線程中執行時，再調用StreamTextureProxyImpl類的成員函數BindToThread中，用來確保在Compositor線程獲得MediaPlayer的解碼輸出通知。

StreamTextureProxyImpl類的成員函數BindOnThread的實現如下所示：

void StreamTextureProxyImpl::BindOnThread(int32 stream_id) {
  host_->BindToCurrentThread(stream_id, this);
}

StreamTextureProxyImpl類的成員變量host_指向的是一個StreamTextureHost對象。StreamTextureProxyImpl類的成員函數BindOnThread調用這個StreamTextureHost對象的成員函數BindToCurrentThread讓其在Compositor線程中接收MediaPlayer的解碼輸出通知，如下所示：

bool StreamTextureHost::BindToCurrentThread(int32 stream_id,
                                            Listener* listener) {
  listener_ = listener;
  if (channel_.get() && stream_id && !stream_id_) {
    stream_id_ = stream_id;
    channel_->AddRoute(stream_id, weak_ptr_factory_.GetWeakPtr());
    channel_->Send(new GpuStreamTextureMsg_StartListening(stream_id));
    return true;
  }

  return false;
}

從前面的調用過程可以知道，參數listener指向的是一個StreamTextureProxyImpl對象。StreamTextureHost類的成員函數BindToCurrentThread首先將這個StreamTextureProxyImpl對象保存在成員變量listener_中。

StreamTextureHost類的另外一個成員變量channel_描述的是一個GPU通道。這個GPU通道就是前面Render請求GPU進程創建SurfaceTexture所用的GPU通道。StreamTextureHost類的成員函數BindToCurrentThread將當前正在處理的StreamTextureHost對象設置為該GPU通道的一個Route，用來接收從GPU進程發送過來的Routing ID為stream_id的IPC消息，也就是那些與前面創建的SurfaceTexture相關的IPC消息。

StreamTextureHost類的成員函數最後通過成員變量channel_描述的GPU通道向GPU進程發送一個類型為GpuStreamTextureMsg_StartListening的IPC消息，表示Render進程已經准備就緒接收MediaPlayer的解碼輸出。

GPU進程通過StreamTexture類的成員函數OnMessageReceived接收類型為GpuStreamTextureMsg_StartListening的IPC消息，如下所示：

bool StreamTexture::OnMessageReceived(const IPC::Message& message) {
  bool handled = true;
  IPC_BEGIN_MESSAGE_MAP(StreamTexture, message)
    IPC_MESSAGE_HANDLER(GpuStreamTextureMsg_StartListening, OnStartListening)
    ......
    IPC_MESSAGE_UNHANDLED(handled = false)
  IPC_END_MESSAGE_MAP()

  DCHECK(handled);
  return handled;
}

StreamTexture類的成員函數OnMessageReceived將類型為StreamTextureMsg_StartListening的IPC消息分發給另外一個成員函數OnStartListening處理，如下所示：

void StreamTexture::OnStartListening() {
  DCHECK(!has_listener_);
  has_listener_ = true;
}

StreamTexture類的成員函數OnStartListening將成員變量has_listener_的值設置為true，表示Render進程准備就緒接收MediaPlayer的解碼輸出。

這一步執行完成之後，Chromium就為

void WebMediaPlayerAndroid::EstablishSurfaceTexturePeer() {
  ......

  if (stream_texture_factory_.get() && stream_id_)
    stream_texture_factory_->EstablishPeer(stream_id_, player_id_);
  
  ......
}

WebMediaPlayerAndroid類的成員函數EstablishSurfaceTexturePeer調用成員變量stream_texture_factory_指向的StreamTextureFactoryImpl對象的成員函數EstablishPeer將之前創建的SurfaceTexture對象設置為MediaPlayer的解碼輸出，如下所示：

void StreamTextureFactoryImpl::EstablishPeer(int32 stream_id, int player_id) {
  DCHECK(channel_.get());
  channel_->Send(
      new GpuStreamTextureMsg_EstablishPeer(stream_id, frame_id_, player_id));
}

StreamTextureFactoryImpl類的成員函數EstablishPeer通過成員變量channel_描述的GPU通道向GPU進程發送一個類型為GpuStreamTextureMsg_EstablishPeer的IPC消息，請求它將之前創建的SurfaceTexture對象設置為MediaPlayer的解碼輸出。

GPU進程通過StreamTexture類的成員函數OnMessageReceived接收類型為GpuStreamTextureMsg_EstablishPeer的IPC消息，如下所示：

bool StreamTexture::OnMessageReceived(const IPC::Message& message) {
  bool handled = true;
  IPC_BEGIN_MESSAGE_MAP(StreamTexture, message)
    ......
    IPC_MESSAGE_HANDLER(GpuStreamTextureMsg_EstablishPeer, OnEstablishPeer)
    ......
    IPC_MESSAGE_UNHANDLED(handled = false)
  IPC_END_MESSAGE_MAP()

  DCHECK(handled);
  return handled;
}

StreamTexture類的成員函數OnMessageReceived將類型為GpuStreamTextureMsg_EstablishPeer的IPC消息分發給另外一個成員函數OnEstablishPeer處理，如下所示：

void StreamTexture::OnEstablishPeer(int32 primary_id, int32 secondary_id) {
  ......

  SurfaceTexturePeer::GetInstance()->EstablishSurfaceTexturePeer(
      process, surface_texture_, primary_id, secondary_id);
}

從前面的分析可以知道，StreamTexture類的成員變量surface_texture_指向的SurfaceTexture對象就是之前Render進程請求GPU進程創建的SurfaceTexture對象。現在需要將這個SurfaceTexture對象設置為MediaPlayer的解碼輸出。這是通過調用運行在GPU進程中的一個SurfaceTexturePeer單例對象的成員函數EstablishSurfaceTexturePeer實現的。

SurfaceTexturePeer類的成員函數EstablishSurfaceTexturePeer的實現如下所示：

void SurfaceTexturePeerBrowserImpl::EstablishSurfaceTexturePeer(
    base::ProcessHandle render_process_handle,
    scoped_refptr surface_texture,
    int render_frame_id,
    int player_id) {
  ......

  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
      &SetSurfacePeer, surface_texture, render_process_handle,
      render_frame_id, player_id));
}

在Android平台中，Chromium的GPU進程與Browser進程實際上是同一個進程。SurfaceTexturePeer類的成員函數EstablishSurfaceTexturePeer於是就在Browser進程的UI線程中執行函數SetSurfacePeer，目的是將參數surface_texture描述的SurfaceTexture對象設置為MediaPlayer的解碼輸出。

函數SetSurfacePeer的實現如下所示：

static void SetSurfacePeer(
    scoped_refptr surface_texture,
    base::ProcessHandle render_process_handle,
    int render_frame_id,
    int player_id) {
  int render_process_id = 0;
  RenderProcessHost::iterator it = RenderProcessHost::AllHostsIterator();
  while (!it.IsAtEnd()) {
    if (it.GetCurrentValue()->GetHandle() == render_process_handle) {
      render_process_id = it.GetCurrentValue()->GetID();
      break;
    }
    it.Advance();
  }
  ......

  RenderFrameHostImpl* frame =
      RenderFrameHostImpl::FromID(render_process_id, render_frame_id);
  ......

  RenderViewHostImpl* view =
      static_cast(frame->GetRenderViewHost());
  BrowserMediaPlayerManager* player_manager =
      view->media_web_contents_observer()->GetMediaPlayerManager(frame);
  ......

  media::MediaPlayerAndroid* player = player_manager->GetPlayer(player_id);
  ......

  if (player != player_manager->GetFullscreenPlayer()) {
    gfx::ScopedJavaSurface scoped_surface(surface_texture);
    player->SetVideoSurface(scoped_surface.Pass());
  }
}

這個函數定義在文件external/chromium_org/content/browser/android/surface_texture_peer_browser_impl.cc中。

函數SetSurfacePeer要做的事情就是在Browser進程找到ID值為player_id的一個MediaPlayerBridge對象，然後將參數surface_texture描述的SurfaceTexture對象設置為它在Java層創建的MediaPlayer的解碼輸出。

為了找到目標MediaPlayerBridge對象，函數SetSurfacePeer首先要找到目標MediaPlayerBridge對象所對應的Render進程。這可以通過參數render_process_handle獲得。然而，知道目標MediaPlayerBridge對象所對應的Render進程還不足夠，因為一個Render進程可能會同時加載多個網頁。Player ID在同一個網頁內才是唯一的。這時候需要用到另外一個參數render_frame_id。這個參數render_frame_id描述的是目標MediaPlayerBridge對象所對應的網頁。

Browser為同一個網頁的

有了這個MediaPlayerBridge對象之後，就可以調用它的成員函數SetVideoSurface將參數surface_texture描述的SurfaceTexture對象設置為它在Java層創建的MediaPlayer的解碼輸出了。不過，只有在

這裡還有一點需要注意，MediaPlayerBridge類是從MediaPlayerAndroid類繼承下來的，因此，函數SetSurfacePeer可以將找到的目標MediaPlayerBridge對象保存在一個MediaPlayerAndroid指針中。

在將參數surface_texture描述的SurfaceTexture對象設置為它在Java層創建的MediaPlayer的解碼輸出之前，函數SetSurfacePeer需要將這個SurfaceTexture對象封裝在一個Surface對象。這是通過ScopedJavaSurface類實現的，如下所示：

ScopedJavaSurface::ScopedJavaSurface(
    const SurfaceTexture* surface_texture)
    : auto_release_(true),
      is_protected_(false) {
  JNIEnv* env = base::android::AttachCurrentThread();
  RegisterNativesIfNeeded(env);
  ScopedJavaLocalRef tmp(JNI_Surface::Java_Surface_Constructor(
      env, surface_texture->j_surface_texture().obj()));
  DCHECK(!tmp.is_null());
  j_surface_.Reset(tmp);
}

ScopedJavaSurface類的構造函數首先是調用參數surface_texture指向的一個C++層的SurfaceTexture對象的成員函數j_surface_texture獲得它在Java層對應的SurfaceTexture對象，然後再以這個Java層的SurfaceTexture為參數，調用JNI接口JNI_Surface::Java_Surface_Constructor在Java層創建一個Surface對象。Java層Surface對象的創建接口，可以參考Android SDK文檔。創建出來的Java層Surface對象，保存在ScopedJavaSurface類的成員變量j_surface_中。

以後通過調用ScopedJavaSurface類的成員函數j_surface可以獲得保存在成員變量j_surface_中的Java層Surface對象，如下所示：

class GL_EXPORT ScopedJavaSurface {
  ......

 public:
  ......

  const base::android::JavaRef& j_surface() const {
    return j_surface_;
  }

 private:
  ......

  base::android::ScopedJavaGlobalRef j_surface_;
};

回到前面分析的函數SetSurfacePeer中，它將參數surface_texture描述的SurfaceTexture對象封裝在一個Java層Surface對象之後，接下來就調用前面找到的目標MediaPlayerBridge對象的成員函數SetVideoSurface將其設置為Java層MediaPlayer的解碼輸出，如下所示：

void MediaPlayerBridge::SetVideoSurface(gfx::ScopedJavaSurface surface) {
  if (j_media_player_bridge_.is_null()) {
    if (surface.IsEmpty())
      return;
    Prepare();
  }

  JNIEnv* env = base::android::AttachCurrentThread();
  CHECK(env);
  is_surface_in_use_ = true;
  Java_MediaPlayerBridge_setSurface(
      env, j_media_player_bridge_.obj(), surface.j_surface().obj());
}

在我們這個情景中，MediaPlayerBridge類的成員變量j_media_player_bridge_指向的Java層MediaPlayerBridge對象已經創建。這時候C++層的MediaPlayerBridge類的成員函數SetVideoSurface就會通過JNI接口Java_MediaPlayerBridge_setSurface調用這個Java層MediaPlayerBridge對象的成員函數setSurface將參數surface描述的Java層Surface設置為它內部創建的MediaPlayer的解碼輸出。

Java層的MediaPlayerBridge類的成員函數setSurface的實現如下所示：

public class MediaPlayerBridge {
    ......

    @CalledByNative
    protected void setSurface(Surface surface) {
        getLocalPlayer().setSurface(surface);
    }

    ......
}

MediaPlayerBridge類的成員函數setSurface首先調用另外一個成員函數getLocalPlayer獲得內部創建的一個MediaPlayer對象。這個MediaPlayer對象描述的就是Android系統提供的播放器實例

從前面的分析可以知道，參數surface描述的Surface對象封裝了一個SurfaceTexture對象。當MediaPlayer開始播放視頻時，它每解碼出來的一幀，都會從上述被封裝的SurfaceTexture對象中獲得一個GPU緩沖區，並且將視頻幀數據寫入到該GPU緩沖區中，然後再通過設置給上述被封裝的SurfaceTexture對象的Frame Available Listener，調用C++層的StreamTexture類的成員函數OnFrameAvailable，用來通知它MediaPlayer有新的解碼輸出需要渲染。

C++層的StreamTexture類的成員函數OnFrameAvailable的實現如下所示：

void StreamTexture::OnFrameAvailable() {
  has_pending_frame_ = true;
  if (has_listener_ && owner_stub_) {
    owner_stub_->channel()->Send(
        new GpuStreamTextureMsg_FrameAvailable(route_id_));
  }
}

這個函數定義在文件external/chromium_org/content/common/gpu/stream_texture_android.cc中。

StreamTexture類的成員函數OnFrameAvailable首先將成員變量has_pending_frame_的值設置為true，表示有一個剛剛解碼出來的視頻幀待處理。

從前面的分析可以知道，StreamTexture類的成員變量has_listener_已經被設置為true。在這種情況下，如果StreamTexture類的成員變量owner_stub_指向了一個GpuCommandBufferStub對象，那麼就說明當前正在處理的StreamTexture對象是為Render進程創建的。這時候就需要向該Render進程發送一個類型為GpuStreamTextureMsg_FrameAvailable的IPC消息，用來通知它MediaPlayer有一個新的解碼輸出。

Render進程通過StreamTextureHost類的成員函數OnMessageReceived接收類型為GpuStreamTextureMsg_FrameAvailable的IPC消息，如下所示：

bool StreamTextureHost::OnMessageReceived(const IPC::Message& message) {
  bool handled = true;
  IPC_BEGIN_MESSAGE_MAP(StreamTextureHost, message)
    IPC_MESSAGE_HANDLER(GpuStreamTextureMsg_FrameAvailable,
                        OnFrameAvailable);
    ......
    IPC_MESSAGE_UNHANDLED(handled = false)
  IPC_END_MESSAGE_MAP()
  DCHECK(handled);
  return handled;
}

StreamTextureHost類的成員函數OnMessageReceived將類型為GpuStreamTextureMsg_FrameAvailable的IPC消息分發給另外一個成員函數OnFrameAvailable處理，如下所示：

void StreamTextureHost::OnFrameAvailable() {
  if (listener_)
    listener_->OnFrameAvailable();
}

從前面的分析可以知道，StreamTextureHost類的成員變量listener_指向的是一個StreamTextureProxyImpl對象。StreamTextureHost類的成員函數OnFrameAvailable調用這個StreamTextureProxyImpl對象的成員函數OnFrameAvailable通知它MediaPlayer有一個新的解碼輸出，如下所示：

void StreamTextureProxyImpl::OnFrameAvailable() {
  base::AutoLock lock(lock_);
  if (client_)
    client_->DidReceiveFrame();
}

從前面的分析可以知道，StreamTextureProxyImpl類的成員變量client_指向的是一個VideoFrameProviderClientImpl對象。StreamTextureProxyImpl類的成員函數OnFrameAvailable調用這個VideoFrameProviderClientImpl對象的成員函數DidReceiveFrame通知它MediaPlayer有一個新的解碼輸出，如下所示：

void VideoFrameProviderClientImpl::DidReceiveFrame() {
  ......
  if (active_video_layer_)
    active_video_layer_->SetNeedsRedraw();
}

VideoFrameProviderClientImpl類的成員變量active_video_layer_指向的是一個VideoLayerImpl對象。這個VideoLayerImpl對象描述的就是

當網頁的CC Active Layer Tree被渲染時，它裡面的每一個Layer的成員函數WillDraw和AppendQuads都會被調用，用來准備要渲染的材料，以便發送給Browser進程進行合成。對於

VideoLayerImpl類的成員函數WillDraw的實現如下所示：

bool VideoLayerImpl::WillDraw(DrawMode draw_mode,
                              ResourceProvider* resource_provider) {
  ......

  frame_ = provider_client_impl_->AcquireLockAndCurrentFrame();
  ......

  if (!updater_) {
    updater_.reset(
        new VideoResourceUpdater(layer_tree_impl()->context_provider(),
                                 layer_tree_impl()->resource_provider()));
  }

  VideoFrameExternalResources external_resources =
      updater_->CreateExternalResourcesFromVideoFrame(frame_);
  frame_resource_type_ = external_resources.type;

  ......

  for (size_t i = 0; i < external_resources.mailboxes.size(); ++i) {
    unsigned resource_id = resource_provider->CreateResourceFromTextureMailbox(
        external_resources.mailboxes[i],
        SingleReleaseCallback::Create(external_resources.release_callbacks[i]));
    frame_resources_.push_back(resource_id);
  }

  return true;
}

從前面的分析可以知道，VideoLayerImpl類的成員變量provider_client_impl_指向的是一個VideoFrameProviderClientImpl對象。VideoLayerImpl類的成員函數WillDraw調用這個VideoFrameProviderClientImpl對象的成員函數AcquireLockAndCurrentFrame獲得一個視頻幀，如下所示：

scoped_refptr
VideoFrameProviderClientImpl::AcquireLockAndCurrentFrame() {
  provider_lock_.Acquire();  // Balanced by call to ReleaseLock().
  if (!provider_)
    return NULL;

  return provider_->GetCurrentFrame();
}

從前面的分析可以知道，VideoFrameProviderClientImpl類的成員變量provider_指向的是一個WebMediaPlayerAndroid對象。VideoFrameProviderClientImpl類的成員函數AcquireLockAndCurrentFrame調用這個WebMediaPlayerAndroid對象的成員函數GetCurrentFrame獲得一個視頻幀，如下所示：

scoped_refptr WebMediaPlayerAndroid::GetCurrentFrame() {
  scoped_refptr video_frame;
  {
    base::AutoLock auto_lock(current_frame_lock_);
    video_frame = current_frame_;
  }

  .......

  return video_frame;
}

從前面的分析可以知道，WebMediaPlayerAndroid類的成員變量current_frame_指向的是一個VideoFrame對象。WebMediaPlayerAndroid類的成員函數GetCurrentFrame將這個這個VideoFrame對象返回給調用者。

這個VideoFrame對象封裝了一個Mailbox。這個Mailbox描述的是一個紋理。前面我們使用這個紋理創建了一個SurfaceTexture對象，並且使用這個SurfaceTexture對象作為MediaPlayer的解碼輸出。因此，有了這個VideoFrame對象，就可以訪問MediaPlayer的解碼輸出。

這一步執行完成後，回到前面分析的VideoLayerImpl類的成員函數WillDraw中，它獲得了一個VideoFrame對象之後，接下來檢查成員變量updater_是否指向了一個VideoResourceUpdater對象。如果沒有，那麼就會先創建一個VideoResourceUpdater對象，並且保存在成員變量updater_中。

有了上述VideoResourceUpdater對象之後，VideoLayerImpl類的成員函數WillDraw就調用它的成員函數CreateExternalResourcesFromVideoFrame根據前面獲得的VideoFrame對象創建一個外部資源對象，如下所示：

VideoFrameExternalResources VideoResourceUpdater::
    CreateExternalResourcesFromVideoFrame(
        const scoped_refptr& video_frame) {
  ......

  if (video_frame->format() == media::VideoFrame::NATIVE_TEXTURE)
    return CreateForHardwarePlanes(video_frame);
  else
    return CreateForSoftwarePlanes(video_frame);
}

從前面的分析可以知道，參數video_frame指向的VideoFrame對象描述的是一個紋理。這時候VideoResourceUpdater類的成員函數CreateExternalResourcesFromVideoFrame會調用另外一個成員函數CreateForHardwarePlanes為它創建一個外部資源對象，如下所示：

VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
    const scoped_refptr& video_frame) {
  ......

  const gpu::MailboxHolder* mailbox_holder = video_frame->mailbox_holder();
  VideoFrameExternalResources external_resources;
  switch (mailbox_holder->texture_target) {
    case GL_TEXTURE_2D:
      external_resources.type = VideoFrameExternalResources::RGB_RESOURCE;
      break;
    case GL_TEXTURE_EXTERNAL_OES:
      external_resources.type =
          VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE;
      break;
    case GL_TEXTURE_RECTANGLE_ARB:
      external_resources.type = VideoFrameExternalResources::IO_SURFACE;
      break;
    default:
      NOTREACHED();
      return VideoFrameExternalResources();
  }

  external_resources.mailboxes.push_back(
      TextureMailbox(mailbox_holder->mailbox,
                     mailbox_holder->texture_target,
                     mailbox_holder->sync_point));
  ......
  return external_resources;
}

參數video_frame指向的VideoFrame對象描述的紋理對象的類型為GL_TEXTURE_EXTERNAL_OES，因此VideoResourceUpdater類的成員函數CreateForHardwarePlanes接下來會創建一個類型為VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE的外部資源對象。這個外部資源對象有一個TextureMailbox列表。VideoResourceUpdater類的成員函數CreateForHardwarePlanes往這個列表中添加了一個TextureMailbox對象。這個TextureMailbox對象引用了參數video_frame指向的VideoFrame對象所描述的紋理對象。

這一步執行完成後，回到前面分析的VideoLayerImpl類的成員函數WillDraw中，這時候它的成員變量frame_resource_type_ 的值就會被設置為VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE。

VideoLayerImpl類的成員函數WillDraw接下來遍歷前面獲得的外部資源對象的Mailbox列表。對於列表裡面的每一個MailboxTexture對象，VideoLayerImpl類的成員函數WillDraw都會調用參數resource_provider指向的一個ResourceProvider對象的成員函數CreateResourceFromTextureMailbox為其創建一個資源對象，如下所示：

ResourceProvider::ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
    const TextureMailbox& mailbox,
    scoped_ptr release_callback) {
  ......

  ResourceId id = next_id_++;
  DCHECK(mailbox.IsValid());
  Resource& resource = resources_[id];
  if (mailbox.IsTexture()) {
    resource = Resource(0,
                        gfx::Size(),
                        Resource::External,
                        mailbox.target(),
                        GL_LINEAR,
                        0,
                        GL_CLAMP_TO_EDGE,
                        TextureUsageAny,
                        RGBA_8888);
  } 

  ......

  resource.allocated = true;
  resource.mailbox = mailbox;
  resource.release_callback =
      base::Bind(&SingleReleaseCallback::Run,
                 base::Owned(release_callback.release()));
  resource.allow_overlay = mailbox.allow_overlay();
  return id;
}

從前面的分析可以知道，參數mailbox指向的TextureMailbox對象描述的是一個紋理。這時候ResourceProvider類的成員函數CreateResourceFromTextureMailbox就會為它創建一個類型為Resource::External的資源對象，並且將這個資源對象的ID返回給調用者。注意，這裡創建的資源對象關聯有一個Mailbox。這個Mailbox由參數mailbox指向的TextureMailbox對象提供，通過它描述的紋理可以訪問MediaPlayer的解碼輸出。

這一步執行完成後，回到前面分析的VideoLayerImpl類的成員函數WillDraw中，這時候它的成員變量frame_resources_描述的一個std::vector就包含了一個資源ID。這個資源ID描述的是一個類型為Resource::External的資源對象。通過這個資源對象關聯的Mailbox可以訪問MediaPlayer的解碼輸出。

VideoLayerImpl類的成員函數WillDraw執行完成之後，我們就為

void VideoLayerImpl::AppendQuads(QuadSink* quad_sink,
                                 AppendQuadsData* append_quads_data) {
  ......

  switch (frame_resource_type_) {
    ......
    case VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE: {
      ......
      gfx::Transform scale;
      scale.Scale(tex_width_scale, tex_height_scale);
      scoped_ptr stream_video_quad =
          StreamVideoDrawQuad::Create();
      stream_video_quad->SetNew(
          shared_quad_state,
          quad_rect,
          opaque_rect,
          visible_quad_rect,
          frame_resources_[0],
          scale * provider_client_impl_->stream_texture_matrix());
      quad_sink->Append(stream_video_quad.PassAs());
      break;
    }
    ......
  }
}

這個StreamVideoDrawQuad對象與前面創建的類型為Resource::External的資源對象關聯，並且描述了這個資源對象所引用的紋理的繪制信息，例如它的紋理坐標、變換矩陣等。由於這個紋理對應的是MediaPlayer的解碼輸出，因此這裡創建的StreamVideoDrawQuad對象實際上描述的是如何將MediaPlayer的解碼輸出繪制在網頁上。

最後，VideoLayerImpl類的成員函數AppendQuads會將創建出來的StreamVideoDrawQuad對象保存在參數append_quads_data指向的一個QuadSink對象中。這個QuadSink對象保存了一系列的DrawQuad。每一個DrawQuad描述的都是網頁的某一部分的渲染信息。對於StreamVideoDrawQuad對象來說，它實際上是一個類型為STREAM_VIDEO_CONTENT的DrawQuad。這些DrawQuad會發送給Browser進程進行渲染。

從前面Chromium硬件加速渲染的UI合成過程分析一文可以知道，Browser進程使用的渲染器由一個GLRenderer對象描述。這個GLRenderer對象會調用成員函數DoDrawQuad對Render進程發送過來的DrawQuad進行渲染，如下所示：

void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
  ......

  switch (quad->material) {
    ......
    case DrawQuad::STREAM_VIDEO_CONTENT:
      DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad));
      break;
    ......
  }
}

對於類型為個類型為STREAM_VIDEO_CONTENT的DrawQuad，GLRenderer類的成員函數DoDrawQuad會調用另外一個成員函數DrawStreamVideoQuad對其進行渲染，如下所示：

void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
                                     const StreamVideoDrawQuad* quad) {
  ......

  const VideoStreamTextureProgram* program =
      GetVideoStreamTextureProgram(tex_coord_precision);
  SetUseProgram(program->program());

  ToGLMatrix(&gl_matrix[0], quad->matrix);
  GLC(gl_,
      gl_->UniformMatrix4fv(
          program->vertex_shader().tex_matrix_location(), 1, false, gl_matrix));

  ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                          quad->resource_id);
  DCHECK_EQ(GL_TEXTURE0, ResourceProvider::GetActiveTextureUnit(gl_));
  GLC(gl_, gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id()));

  GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));

  ......

  DrawQuadGeometry(frame,
                   quad->quadTransform(),
                   quad->rect,
                   program->vertex_shader().matrix_location());
}

類型為STREAM_VIDEO_CONTENT的DrawQuad描述的是一個紋理，GLRenderer類的成員函數DrawStreamVideoQuad通過調用另外一個成員函數DrawQuadGeometry對這個紋理進行渲染，如下所示：

void GLRenderer::DrawQuadGeometry(const DrawingFrame* frame,
                                  const gfx::Transform& draw_transform,
                                  const gfx::RectF& quad_rect,
                                  int matrix_location) {
  gfx::Transform quad_rect_matrix;
  QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect);
  static float gl_matrix[16];
  ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad_rect_matrix);
  GLC(gl_, gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]));

  GLC(gl_, gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0));
}

GLRenderer類的成員變量gl_描述的一個Command Buffer GL接口，也就是一個GLES2Implementation對象。GLRenderer類的成員函數DrawQuadGeometry調用這個GLES2Implementation對象的成員函數DrawElements對參數frame描述的紋理進行渲染，實際上就是通過Command Buffer向GPU進程發送了一個gles2::cmds::DrawElements命令。

GPU進程通過調用GLES2DecoderImpl類的成員函數DoDrawElements執行Render進程發送過來的gles2::cmds::DrawElements命令，如下所示：

error::Error GLES2DecoderImpl::DoDrawElements(
    const char* function_name,
    bool instanced,
    GLenum mode,
    GLsizei count,
    GLenum type,
    int32 offset,
    GLsizei primcount) {
  ......

  if (IsDrawValid(function_name, max_vertex_accessed, primcount)) {
    ......
    if (SimulateFixedAttribs(
        function_name, max_vertex_accessed, &simulated_fixed_attribs,
        primcount)) {
      bool textures_set = !PrepareTexturesForRender();
      ......

      ScopedRenderTo do_render(framebuffer_state_.bound_draw_framebuffer.get());
      if (!instanced) {
        glDrawElements(mode, count, type, indices);
      } else {
        glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
      }
      ......
    }
    ......
  }
  return error::kNoError;
}

GLES2DecoderImpl類的成員函數DoDrawElements首先調用成員函數IsDrawValid檢查當前正在處理的gles2::cmds::DrawElements命令指定的頂點信息是否有效。如果有效，GLES2DecoderImpl類的成員函數IsDrawValid的返回值就等於true。

GLES2DecoderImpl類的成員函數DoDrawElements接下來調用成員函數SimulateFixedAttribs檢查當前正在處理的gles2::cmds::DrawElements命令是否使用了GLfixed類型的頂點屬性。如果沒有使用，或者使用了，並且當前加載的OpenGL庫支持，那麼GLES2DecoderImpl類的成員函數SimulateFixedAttribs的返回值就等於true。

通過了以上兩個檢查之後，GLES2DecoderImpl類的成員函數DoDrawElements接下來就會調用真正的OpenGL函數glDrawElements或者glDrawElementsInstancedANGLE執行當前正在處理的gles2::cmds::DrawElements命令。在我們這個情景中，就是繪制這個命令所指定的紋理。

不過，在調用OpenGL函數glDrawElements或者glDrawElementsInstancedANGLE之前，GLES2DecoderImpl類的成員函數DoDrawElements需要調用另外一個成員函數PrepareTexturesForRender做一些准備工作。例如，在我們這個情景中，要將MediaPlayer的最新解碼輸出設置為要繪制的紋理的後端存儲。這樣在繪制紋理的時候，才能將

GLES2DecoderImpl類的成員函數PrepareTexturesForRender的實現如下所示：

bool GLES2DecoderImpl::PrepareTexturesForRender() {
  ......

  bool textures_set = false;
  const Program::SamplerIndices& sampler_indices =
     state_.current_program->sampler_indices();
  for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
    const Program::UniformInfo* uniform_info =
        state_.current_program->GetUniformInfo(sampler_indices[ii]);
    ......
    for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
      GLuint texture_unit_index = uniform_info->texture_units[jj];
      if (texture_unit_index < state_.texture_units.size()) {
        TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
        TextureRef* texture_ref =
            texture_unit.GetInfoForSamplerType(uniform_info->type).get();
        GLenum textarget = GetBindTargetForSamplerType(uniform_info->type);
        ......

        if (textarget != GL_TEXTURE_CUBE_MAP) {
          Texture* texture = texture_ref->texture();
          gfx::GLImage* image = texture->GetLevelImage(textarget, 0);
          if (image && !texture->IsAttachedToFramebuffer()) {
            ......
            textures_set = true;
            glActiveTexture(GL_TEXTURE0 + texture_unit_index);
            image->WillUseTexImage();
            continue;
          }
        }
      }
      // else: should this be an error?
    }
  }
  return !textures_set;
}

GLES2DecoderImpl類的成員函數PrepareTexturesForRender所做的事情就是遍歷與當前所用的OpenGL Program相關的每一個紋理。對於那些類型不等於GL_TEXTURE_CUBE_MAP、關聯有GLImage對象、不與FBO綁定（與FBO綁定意味著將內容繪制它裡面去而不是將它的內容繪制出來）的紋理，GLES2DecoderImpl類的成員函數PrepareTexturesForRender將會調用它們關聯的GLImage對象的成員函數WillUseTexImage，表示它們現在可以做一些准備工作，以便接下來可以進行繪制。

從前面的調用過程可以知道，當前我們要繪制的是一個類型為GL_TEXTURE_EXTERNAL_OES，並且關聯有一個StreamTexture對象紋理。這個StreamTexture對象是前面Render進程請求GPU進程創建SurfaceTexture的過程中創建的。StreamTexture類是從GLImage類繼承下來的，並且它重寫了父類的成員函數WillUseTexImage。因此，接下來StreamTexture類的成員函數WillUseTexImage就會被調用，它的實現如下所示：

void StreamTexture::WillUseTexImage() {
  ......

  if (has_pending_frame_) {
    ......
    surface_texture_->UpdateTexImage();
    ......
    has_pending_frame_ = false;
    ......
  }

  ......
}

從前面的分析可以知道，當StreamTexture類的成員變量has_pending_frame_的值等於true的時候，就表示MediaPlayer解碼了一個新的視頻幀，並且這個新的視頻幀正在等待處理。要做的處理就是將新的視頻幀內容作為當前要繪制的紋理的底端存儲。這樣在繪制這個紋理的時候，才能將新解碼出來的視頻幀顯示出來。這可以通過調用StreamTexture類的成員變量surface_texture_指向的一個C++層SurfaceTexture對象的成員函數UpdateTexImage實現。

每一個C++層SurfaceTexture對象在Java層都有一個對應的SurfaceTexture對象。當C++層SurfaceTexture對象的成員函數UpdateTexImage被調用時，它會通過JNI調用它在Java層對應的SurfaceTexture對象的成員函數updateTexImage。這個Java層的SurfaceTexture對象前面已經被設置為MediaPlayer的解碼輸出。因此，這一步執行完成之後，MediaPlayer新解碼出來的視頻幀就會被設置為當前要繪制的紋理的底端存儲。

至此，我們就分析完成了

在全屏播放模式下，