// Copyright (c) 2015 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/skia_runner/in_process_graphics_system.h"

#include <iostream>

#include "base/lazy_instance.h"
#include "base/memory/discardable_memory.h"
#include "base/memory/discardable_memory_allocator.h"
#include "base/thread_task_runner_handle.h"
#include "base/trace_event/memory_allocator_dump.h"
#include "base/trace_event/memory_dump_manager.h"
#include "base/trace_event/process_memory_dump.h"
#include "gpu/command_buffer/client/gles2_implementation.h"
#include "gpu/command_buffer/client/gles2_lib.h"
#include "gpu/skia_bindings/gl_bindings_skia_cmd_buffer.h"
#include "third_party/khronos/GLES2/gl2.h"
#include "third_party/skia/include/gpu/gl/GrGLInterface.h"

namespace {

// TODO(hendrikw): Replace TestDiscardableMemoryAllocator and move to base?
class NonDiscardableMemory : public base::DiscardableMemory {
 public:
  explicit NonDiscardableMemory(size_t size)
      : data_(new uint8_t[size]), size_(size) {}
  bool Lock() override { return false; }
  void Unlock() override {}
  void* data() const override { return data_.get(); }

  base::trace_event::MemoryAllocatorDump* CreateMemoryAllocatorDump(
      const char* name,
      base::trace_event::ProcessMemoryDump* pmd) const override {
    base::trace_event::MemoryAllocatorDump* dump =
        pmd->CreateAllocatorDump(name);
    dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                    base::trace_event::MemoryAllocatorDump::kUnitsBytes, size_);

    // Memory is allocated from system allocator (malloc).
    pmd->AddSuballocation(dump->guid(),
                          base::trace_event::MemoryDumpManager::GetInstance()
                              ->system_allocator_pool_name());
    return dump;
  }

 private:
  scoped_ptr<uint8_t[]> data_;
  size_t size_;
};

class NonDiscardableMemoryAllocator : public base::DiscardableMemoryAllocator {
 public:
  // Overridden from DiscardableMemoryAllocator:
  scoped_ptr<base::DiscardableMemory> AllocateLockedDiscardableMemory(
      size_t size) override {
    return make_scoped_ptr(new NonDiscardableMemory(size));
  }
};

// Singleton used to initialize and terminate the gles2 library.
class GLES2Initializer {
 public:
  GLES2Initializer() { gles2::Initialize(); }
  ~GLES2Initializer() { gles2::Terminate(); }

 private:
  DISALLOW_COPY_AND_ASSIGN(GLES2Initializer);
};

base::LazyInstance<GLES2Initializer> g_gles2_initializer =
    LAZY_INSTANCE_INITIALIZER;
base::LazyInstance<NonDiscardableMemoryAllocator> g_discardable;

}  // namespace anonymous

namespace skia_runner {

void BindContext3DGLContextCallback(const GrGLInterface* gl_interface) {
  gles2::SetGLContext(reinterpret_cast<gpu::GLInProcessContext*>(
                          gl_interface->fCallbackData)->GetImplementation());
}

InProcessGraphicsSystem::InProcessGraphicsSystem() {
  base::DiscardableMemoryAllocator::SetInstance(&g_discardable.Get());
  g_gles2_initializer.Get();

  if (!gfx::GLSurface::InitializeOneOff()) {
    LOG(ERROR) << "Unable to initialize gfx::GLSurface.";
    return;
  }

  // Create the in process context.
  in_process_context_ = CreateInProcessContext();
  if (!in_process_context_) {
    LOG(ERROR) << "Unable to create in process context.";
    return;
  }

  // Create and set up skia's GL bindings.
  gles2::SetGLContext(in_process_context_->GetImplementation());
  GrGLInterface* bindings = skia_bindings::CreateCommandBufferSkiaGLBinding();
  if (!bindings) {
    LOG(ERROR) << "Unable to create skia command buffer bindings.";
    return;
  }

  bindings->fCallback = BindContext3DGLContextCallback;
  bindings->fCallbackData =
      reinterpret_cast<GrGLInterfaceCallbackData>(in_process_context_.get());

  // Create skia's graphics context.
  gr_context_ = skia::AdoptRef(GrContext::Create(
      kOpenGL_GrBackend, reinterpret_cast<GrBackendContext>(bindings)));

  if (!gr_context_) {
    LOG(ERROR) << "Unable to create skia graphics context.";
    return;
  }

  // Set skia's graphics context cache size.
  const int kMaxGaneshResourceCacheCount = 2048;
  const size_t kMaxGaneshResourceCacheBytes = 96 * 1024 * 1024;
  gr_context_->setResourceCacheLimits(kMaxGaneshResourceCacheCount,
                                      kMaxGaneshResourceCacheBytes);
}

InProcessGraphicsSystem::~InProcessGraphicsSystem() {
}

bool InProcessGraphicsSystem::IsSuccessfullyInitialized() const {
  return gr_context_;
}

int InProcessGraphicsSystem::GetMaxTextureSize() const {
  int max_texture_size = 0;
  in_process_context_->GetImplementation()->GetIntegerv(GL_MAX_TEXTURE_SIZE,
                                                        &max_texture_size);
  return max_texture_size;
}

scoped_ptr<gpu::GLInProcessContext>
InProcessGraphicsSystem::CreateInProcessContext() const {
  const bool is_offscreen = true;
  const bool share_resources = true;
  gpu::gles2::ContextCreationAttribHelper attribs;
  attribs.alpha_size = 8;
  attribs.blue_size = 8;
  attribs.green_size = 8;
  attribs.red_size = 8;
  attribs.depth_size = 24;
  attribs.stencil_size = 8;
  attribs.samples = 0;
  attribs.sample_buffers = 0;
  attribs.fail_if_major_perf_caveat = false;
  attribs.bind_generates_resource = false;
  gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;

  scoped_ptr<gpu::GLInProcessContext> context =
      make_scoped_ptr(gpu::GLInProcessContext::Create(
          nullptr, nullptr, is_offscreen, gfx::kNullAcceleratedWidget,
          gfx::Size(1, 1), nullptr, share_resources, attribs, gpu_preference,
          gpu::GLInProcessContextSharedMemoryLimits(), nullptr, nullptr));

  DCHECK(context);
  return context.Pass();
}

}  // namespace skia_runner