Line data    Source code

       1             : /*
       2             :  * Copyright 2014 Google Inc.
       3             :  *
       4             :  * Use of this source code is governed by a BSD-style license that can be
       5             :  * found in the LICENSE file.
       6             :  */
       7             : 
       8             : #include "GrGpuResourceRef.h"
       9             : 
      10           0 : GrGpuResourceRef::GrGpuResourceRef() {
      11           0 :     fResource = nullptr;
      12           0 :     fOwnRef = false;
      13           0 :     fPendingIO = false;
      14           0 : }
      15             : 
      16           0 : GrGpuResourceRef::GrGpuResourceRef(GrGpuResource* resource, GrIOType ioType) {
      17           0 :     fResource = nullptr;
      18           0 :     fOwnRef = false;
      19           0 :     fPendingIO = false;
      20           0 :     this->setResource(resource, ioType);
      21           0 : }
      22             : 
      23           0 : GrGpuResourceRef::~GrGpuResourceRef() {
      24           0 :     if (fOwnRef) {
      25           0 :         SkASSERT(fResource);
      26           0 :         fResource->unref();
      27             :     }
      28           0 :     if (fPendingIO) {
      29           0 :         switch (fIOType) {
      30             :             case kRead_GrIOType:
      31           0 :                 fResource->completedRead();
      32           0 :                 break;
      33             :             case kWrite_GrIOType:
      34           0 :                 fResource->completedWrite();
      35           0 :                 break;
      36             :             case kRW_GrIOType:
      37           0 :                 fResource->completedRead();
      38           0 :                 fResource->completedWrite();
      39           0 :                 break;
      40             :         }
      41             :     }
      42           0 : }
      43             : 
      44           0 : void GrGpuResourceRef::reset() {
      45           0 :     SkASSERT(!fPendingIO);
      46           0 :     SkASSERT(SkToBool(fResource) == fOwnRef);
      47           0 :     if (fOwnRef) {
      48           0 :         fResource->unref();
      49           0 :         fOwnRef = false;
      50           0 :         fResource = nullptr;
      51             :     }
      52           0 : }
      53             : 
      54           0 : void GrGpuResourceRef::setResource(GrGpuResource* resource, GrIOType ioType) {
      55           0 :     SkASSERT(!fPendingIO);
      56           0 :     SkASSERT(SkToBool(fResource) == fOwnRef);
      57           0 :     SkSafeUnref(fResource);
      58           0 :     if (nullptr == resource) {
      59           0 :         fResource = nullptr;
      60           0 :         fOwnRef = false;
      61             :     } else {
      62           0 :         fResource = resource;
      63           0 :         fOwnRef = true;
      64           0 :         fIOType = ioType;
      65             :     }
      66           0 : }
      67             : 
      68           0 : void GrGpuResourceRef::markPendingIO() const {
      69             :     // This should only be called when the owning GrProgramElement gets its first
      70             :     // pendingExecution ref.
      71           0 :     SkASSERT(!fPendingIO);
      72           0 :     SkASSERT(fResource);
      73           0 :     fPendingIO = true;
      74           0 :     switch (fIOType) {
      75             :         case kRead_GrIOType:
      76           0 :             fResource->addPendingRead();
      77           0 :             break;
      78             :         case kWrite_GrIOType:
      79           0 :             fResource->addPendingWrite();
      80           0 :             break;
      81             :         case kRW_GrIOType:
      82           0 :             fResource->addPendingRead();
      83           0 :             fResource->addPendingWrite();
      84           0 :             break;
      85             :     }
      86           0 : }
      87             : 
      88           0 : void GrGpuResourceRef::pendingIOComplete() const {
      89             :     // This should only be called when the owner's pending executions have ocurred but it is still
      90             :     // reffed.
      91           0 :     SkASSERT(fOwnRef);
      92           0 :     SkASSERT(fPendingIO);
      93           0 :     switch (fIOType) {
      94             :         case kRead_GrIOType:
      95           0 :             fResource->completedRead();
      96           0 :             break;
      97             :         case kWrite_GrIOType:
      98           0 :             fResource->completedWrite();
      99           0 :             break;
     100             :         case kRW_GrIOType:
     101           0 :             fResource->completedRead();
     102           0 :             fResource->completedWrite();
     103           0 :             break;
     104             : 
     105             :     }
     106           0 :     fPendingIO = false;
     107           0 : }
     108             : 
     109           0 : void GrGpuResourceRef::removeRef() const {
     110             :     // This should only be called once, when the owners last ref goes away and
     111             :     // there is a pending execution.
     112           0 :     SkASSERT(fOwnRef);
     113           0 :     SkASSERT(fPendingIO);
     114           0 :     SkASSERT(fResource);
     115           0 :     fResource->unref();
     116           0 :     fOwnRef = false;
     117           0 : }