command_buffer/service/test_shared_image_backing.cc

// Copyright 2019 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/test_shared_image_backing.h"
#include "build/build_config.h"
#include "components/viz/common/resources/resource_format_utils.h"
#include "gpu/command_buffer/service/shared_context_state.h"
#include "third_party/skia/include/core/SkPromiseImageTexture.h"
#include "third_party/skia/include/gpu/GrBackendSurface.h"
#include "third_party/skia/include/gpu/mock/GrMockTypes.h"

namespace gpu {
namespace {
class TestSharedImageRepresentationGLTexture
    : public SharedImageRepresentationGLTexture {
 public:
  TestSharedImageRepresentationGLTexture(SharedImageManager* manager,
                                         SharedImageBacking* backing,
                                         MemoryTypeTracker* tracker,
                                         gles2::Texture* texture)
      : SharedImageRepresentationGLTexture(manager, backing, tracker),
        texture_(texture) {}

  gles2::Texture* GetTexture() override { return texture_; }
  bool BeginAccess(GLenum mode) override {
    return static_cast<TestSharedImageBacking*>(backing())->can_access();
  }

 private:
  gles2::Texture* const texture_;
};

class TestSharedImageRepresentationGLTexturePassthrough
    : public SharedImageRepresentationGLTexturePassthrough {
 public:
  TestSharedImageRepresentationGLTexturePassthrough(
      SharedImageManager* manager,
      SharedImageBacking* backing,
      MemoryTypeTracker* tracker,
      scoped_refptr<gles2::TexturePassthrough> texture)
      : SharedImageRepresentationGLTexturePassthrough(manager,
                                                      backing,
                                                      tracker),
        texture_(std::move(texture)) {}

  const scoped_refptr<gles2::TexturePassthrough>& GetTexturePassthrough()
      override {
    return texture_;
  }
  bool BeginAccess(GLenum mode) override {
    return static_cast<TestSharedImageBacking*>(backing())->can_access();
  }

 private:
  const scoped_refptr<gles2::TexturePassthrough> texture_;
};

class TestSharedImageRepresentationSkia : public SharedImageRepresentationSkia {
 public:
  TestSharedImageRepresentationSkia(SharedImageManager* manager,
                                    SharedImageBacking* backing,
                                    MemoryTypeTracker* tracker)
      : SharedImageRepresentationSkia(manager, backing, tracker) {}

 protected:
  sk_sp<SkSurface> BeginWriteAccess(
      int final_msaa_count,
      const SkSurfaceProps& surface_props,
      std::vector<GrBackendSemaphore>* begin_semaphores,
      std::vector<GrBackendSemaphore>* end_semaphores) override {
    if (!static_cast<TestSharedImageBacking*>(backing())->can_access()) {
      return nullptr;
    }
    return SkSurface::MakeRasterN32Premul(size().width(), size().height());
  }
  void EndWriteAccess(sk_sp<SkSurface> surface) override {}
  sk_sp<SkPromiseImageTexture> BeginReadAccess(
      std::vector<GrBackendSemaphore>* begin_semaphores,
      std::vector<GrBackendSemaphore>* end_semaphores) override {
    if (!static_cast<TestSharedImageBacking*>(backing())->can_access()) {
      return nullptr;
    }
    GrBackendTexture backend_tex(size().width(), size().height(),
                                 GrMipMapped::kNo, GrMockTextureInfo());
    return SkPromiseImageTexture::Make(backend_tex);
  }
  void EndReadAccess() override {}
};

class TestSharedImageRepresentationDawn : public SharedImageRepresentationDawn {
 public:
  TestSharedImageRepresentationDawn(SharedImageManager* manager,
                                    SharedImageBacking* backing,
                                    MemoryTypeTracker* tracker)
      : SharedImageRepresentationDawn(manager, backing, tracker) {}

  WGPUTexture BeginAccess(WGPUTextureUsage usage) override {
    if (!static_cast<TestSharedImageBacking*>(backing())->can_access()) {
      return nullptr;
    }

    // Return a dummy value.
    return reinterpret_cast<WGPUTexture>(203);
  }

  void EndAccess() override {}
};

class TestSharedImageRepresentationOverlay
    : public SharedImageRepresentationOverlay {
 public:
  TestSharedImageRepresentationOverlay(SharedImageManager* manager,
                                       SharedImageBacking* backing,
                                       MemoryTypeTracker* tracker)
      : SharedImageRepresentationOverlay(manager, backing, tracker) {}

  bool BeginReadAccess() override { return true; }
  void EndReadAccess() override {}
  gl::GLImage* GetGLImage() override { return nullptr; }

#if defined(OS_ANDROID)
  void NotifyOverlayPromotion(bool promotion,
                              const gfx::Rect& bounds) override {}
#endif
};

}  // namespace

TestSharedImageBacking::TestSharedImageBacking(
    const Mailbox& mailbox,
    viz::ResourceFormat format,
    const gfx::Size& size,
    const gfx::ColorSpace& color_space,
    uint32_t usage,
    size_t estimated_size,
    GLuint texture_id)
    : SharedImageBacking(mailbox,
                         format,
                         size,
                         color_space,
                         usage,
                         estimated_size,
                         false /* is_thread_safe */),
      service_id_(texture_id) {
  texture_ = new gles2::Texture(service_id_);
  texture_->SetLightweightRef();
  texture_->SetTarget(GL_TEXTURE_2D, 1);
  texture_->sampler_state_.min_filter = GL_LINEAR;
  texture_->sampler_state_.mag_filter = GL_LINEAR;
  texture_->sampler_state_.wrap_s = GL_CLAMP_TO_EDGE;
  texture_->sampler_state_.wrap_t = GL_CLAMP_TO_EDGE;
  texture_->SetLevelInfo(GL_TEXTURE_2D, 0, GLInternalFormat(format),
                         size.width(), size.height(), 1, 0,
                         GLDataFormat(format), GLDataType(format), gfx::Rect());
  texture_->SetImmutable(true, true);
  texture_passthrough_ = base::MakeRefCounted<gles2::TexturePassthrough>(
      service_id_, GL_TEXTURE_2D);
}

TestSharedImageBacking::TestSharedImageBacking(
    const Mailbox& mailbox,
    viz::ResourceFormat format,
    const gfx::Size& size,
    const gfx::ColorSpace& color_space,
    uint32_t usage,
    size_t estimated_size)
    : TestSharedImageBacking(mailbox,
                             format,
                             size,
                             color_space,
                             usage,
                             estimated_size,
                             203 /* texture_id */) {
  // Using a dummy |texture_id|, so lose our context so we don't do anything
  // real with it.
  OnContextLost();
}

TestSharedImageBacking::~TestSharedImageBacking() {
  // Pretend our context is lost to avoid actual cleanup in |texture_| or
  // |passthrough_texture_|.
  texture_->RemoveLightweightRef(false /* have_context */);
  texture_passthrough_->MarkContextLost();
  texture_passthrough_.reset();

  if (have_context())
    glDeleteTextures(1, &service_id_);
}

gfx::Rect TestSharedImageBacking::ClearedRect() const {
  return texture_->GetLevelClearedRect(texture_->target(), 0);
}

void TestSharedImageBacking::SetClearedRect(const gfx::Rect& cleared_rect) {
  texture_->SetLevelClearedRect(texture_->target(), 0, cleared_rect);
}

bool TestSharedImageBacking::ProduceLegacyMailbox(
    MailboxManager* mailbox_manager) {
  return false;
}

std::unique_ptr<SharedImageRepresentationGLTexture>
TestSharedImageBacking::ProduceGLTexture(SharedImageManager* manager,
                                         MemoryTypeTracker* tracker) {
  return std::make_unique<TestSharedImageRepresentationGLTexture>(
      manager, this, tracker, texture_);
}

std::unique_ptr<SharedImageRepresentationGLTexturePassthrough>
TestSharedImageBacking::ProduceGLTexturePassthrough(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker) {
  return std::make_unique<TestSharedImageRepresentationGLTexturePassthrough>(
      manager, this, tracker, texture_passthrough_);
}

std::unique_ptr<SharedImageRepresentationSkia>
TestSharedImageBacking::ProduceSkia(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker,
    scoped_refptr<SharedContextState> context_state) {
  return std::make_unique<TestSharedImageRepresentationSkia>(manager, this,
                                                             tracker);
}

std::unique_ptr<SharedImageRepresentationDawn>
TestSharedImageBacking::ProduceDawn(SharedImageManager* manager,
                                    MemoryTypeTracker* tracker,
                                    WGPUDevice device) {
  return std::make_unique<TestSharedImageRepresentationDawn>(manager, this,
                                                             tracker);
}

std::unique_ptr<SharedImageRepresentationOverlay>
TestSharedImageBacking::ProduceOverlay(SharedImageManager* manager,
                                       MemoryTypeTracker* tracker) {
  return std::make_unique<TestSharedImageRepresentationOverlay>(manager, this,
                                                                tracker);
}

}  // namespace gpu