Home | History | Annotate | Download | only in service 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "gpu/command_buffer/service/async_pixel_transfer_manager_sync.h"
      6 
      7 #include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
      8 
      9 namespace gpu {
     10 
     11 // Class which handles async pixel transfers synchronously.
     12 class AsyncPixelTransferDelegateSync : public AsyncPixelTransferDelegate {
     13  public:
     14   explicit AsyncPixelTransferDelegateSync(
     15       AsyncPixelTransferManagerSync::SharedState* shared_state);
     16   virtual ~AsyncPixelTransferDelegateSync();
     17 
     18   // Implement AsyncPixelTransferDelegate:
     19   virtual void AsyncTexImage2D(
     20       const AsyncTexImage2DParams& tex_params,
     21       const AsyncMemoryParams& mem_params,
     22       const base::Closure& bind_callback) OVERRIDE;
     23   virtual void AsyncTexSubImage2D(
     24       const AsyncTexSubImage2DParams& tex_params,
     25       const AsyncMemoryParams& mem_params) OVERRIDE;
     26   virtual bool TransferIsInProgress() OVERRIDE;
     27   virtual void WaitForTransferCompletion() OVERRIDE;
     28 
     29  private:
     30   // Safe to hold a raw pointer because SharedState is owned by the Manager
     31   // which owns the Delegate.
     32   AsyncPixelTransferManagerSync::SharedState* shared_state_;
     33 
     34   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateSync);
     35 };
     36 
     37 AsyncPixelTransferDelegateSync::AsyncPixelTransferDelegateSync(
     38     AsyncPixelTransferManagerSync::SharedState* shared_state)
     39     : shared_state_(shared_state) {}
     40 
     41 AsyncPixelTransferDelegateSync::~AsyncPixelTransferDelegateSync() {}
     42 
     43 void AsyncPixelTransferDelegateSync::AsyncTexImage2D(
     44     const AsyncTexImage2DParams& tex_params,
     45     const AsyncMemoryParams& mem_params,
     46     const base::Closure& bind_callback) {
     47   // Save the define params to return later during deferred
     48   // binding of the transfer texture.
     49   void* data = mem_params.GetDataAddress();
     50   base::TimeTicks begin_time(base::TimeTicks::HighResNow());
     51   glTexImage2D(
     52       tex_params.target,
     53       tex_params.level,
     54       tex_params.internal_format,
     55       tex_params.width,
     56       tex_params.height,
     57       tex_params.border,
     58       tex_params.format,
     59       tex_params.type,
     60       data);
     61   shared_state_->texture_upload_count++;
     62   shared_state_->total_texture_upload_time +=
     63       base::TimeTicks::HighResNow() - begin_time;
     64   // The texture is already fully bound so just call it now.
     65   bind_callback.Run();
     66 }
     67 
     68 void AsyncPixelTransferDelegateSync::AsyncTexSubImage2D(
     69     const AsyncTexSubImage2DParams& tex_params,
     70     const AsyncMemoryParams& mem_params) {
     71   void* data = mem_params.GetDataAddress();
     72   base::TimeTicks begin_time(base::TimeTicks::HighResNow());
     73   glTexSubImage2D(
     74       tex_params.target,
     75       tex_params.level,
     76       tex_params.xoffset,
     77       tex_params.yoffset,
     78       tex_params.width,
     79       tex_params.height,
     80       tex_params.format,
     81       tex_params.type,
     82       data);
     83   shared_state_->texture_upload_count++;
     84   shared_state_->total_texture_upload_time +=
     85       base::TimeTicks::HighResNow() - begin_time;
     86 }
     87 
     88 bool AsyncPixelTransferDelegateSync::TransferIsInProgress() {
     89   // Already done.
     90   return false;
     91 }
     92 
     93 void AsyncPixelTransferDelegateSync::WaitForTransferCompletion() {
     94   // Already done.
     95 }
     96 
     97 AsyncPixelTransferManagerSync::SharedState::SharedState()
     98     : texture_upload_count(0) {}
     99 
    100 AsyncPixelTransferManagerSync::SharedState::~SharedState() {}
    101 
    102 AsyncPixelTransferManagerSync::AsyncPixelTransferManagerSync() {}
    103 
    104 AsyncPixelTransferManagerSync::~AsyncPixelTransferManagerSync() {}
    105 
    106 void AsyncPixelTransferManagerSync::BindCompletedAsyncTransfers() {
    107   // Everything is already bound.
    108 }
    109 
    110 void AsyncPixelTransferManagerSync::AsyncNotifyCompletion(
    111     const AsyncMemoryParams& mem_params,
    112     AsyncPixelTransferCompletionObserver* observer) {
    113   observer->DidComplete(mem_params);
    114 }
    115 
    116 uint32 AsyncPixelTransferManagerSync::GetTextureUploadCount() {
    117   return shared_state_.texture_upload_count;
    118 }
    119 
    120 base::TimeDelta AsyncPixelTransferManagerSync::GetTotalTextureUploadTime() {
    121   return shared_state_.total_texture_upload_time;
    122 }
    123 
    124 void AsyncPixelTransferManagerSync::ProcessMorePendingTransfers() {
    125 }
    126 
    127 bool AsyncPixelTransferManagerSync::NeedsProcessMorePendingTransfers() {
    128   return false;
    129 }
    130 
    131 void AsyncPixelTransferManagerSync::WaitAllAsyncTexImage2D() {
    132 }
    133 
    134 AsyncPixelTransferDelegate*
    135 AsyncPixelTransferManagerSync::CreatePixelTransferDelegateImpl(
    136     gles2::TextureRef* ref,
    137     const AsyncTexImage2DParams& define_params) {
    138   return new AsyncPixelTransferDelegateSync(&shared_state_);
    139 }
    140 
    141 }  // namespace gpu
    142