content/browser/renderer_host/offscreen_canvas_provider_impl_unittest.cc

// Copyright 2017 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 "content/browser/renderer_host/offscreen_canvas_provider_impl.h"

#include <algorithm>
#include <utility>
#include <vector>

#include "base/memory/ptr_util.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "cc/ipc/mojo_compositor_frame_sink.mojom.h"
#include "cc/output/compositor_frame.h"
#include "content/browser/compositor/test/no_transport_image_transport_factory.h"
#include "content/browser/renderer_host/offscreen_canvas_surface_impl.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/WebKit/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom.h"

#if !defined(OS_ANDROID)
#include "content/browser/compositor/image_transport_factory.h"
#endif

using testing::ElementsAre;
using testing::IsEmpty;

namespace content {
namespace {

constexpr uint32_t kRendererClientId = 3;
constexpr cc::FrameSinkId kFrameSinkParent(kRendererClientId, 1);
constexpr cc::FrameSinkId kFrameSinkA(kRendererClientId, 3);
constexpr cc::FrameSinkId kFrameSinkB(kRendererClientId, 4);

// Stub OffscreenCanvasSurfaceClient that stores the latest SurfaceInfo.
class StubOffscreenCanvasSurfaceClient
    : public blink::mojom::OffscreenCanvasSurfaceClient {
 public:
  StubOffscreenCanvasSurfaceClient() : binding_(this) {}
  ~StubOffscreenCanvasSurfaceClient() override {}

  blink::mojom::OffscreenCanvasSurfaceClientPtr GetInterfacePtr() {
    return binding_.CreateInterfacePtrAndBind();
  }

  const cc::SurfaceInfo& GetLastSurfaceInfo() const {
    return last_surface_info_;
  }

 private:
  // blink::mojom::OffscreenCanvasSurfaceClient:
  void OnSurfaceCreated(const cc::SurfaceInfo& surface_info) override {
    last_surface_info_ = surface_info;
  }

  mojo::Binding<blink::mojom::OffscreenCanvasSurfaceClient> binding_;
  cc::SurfaceInfo last_surface_info_;

  DISALLOW_COPY_AND_ASSIGN(StubOffscreenCanvasSurfaceClient);
};

// Stub MojoCompositorFrameSinkClient that does nothing.
class StubCompositorFrameSinkClient
    : public cc::mojom::MojoCompositorFrameSinkClient {
 public:
  StubCompositorFrameSinkClient() : binding_(this) {}
  ~StubCompositorFrameSinkClient() override {}

  cc::mojom::MojoCompositorFrameSinkClientPtr GetInterfacePtr() {
    return binding_.CreateInterfacePtrAndBind();
  }

 private:
  // cc::mojom::MojoCompositorFrameSinkClient:
  void DidReceiveCompositorFrameAck(
      const cc::ReturnedResourceArray& resources) override {}
  void OnBeginFrame(const cc::BeginFrameArgs& begin_frame_args) override {}
  void ReclaimResources(const cc::ReturnedResourceArray& resources) override {}

  mojo::Binding<cc::mojom::MojoCompositorFrameSinkClient> binding_;

  DISALLOW_COPY_AND_ASSIGN(StubCompositorFrameSinkClient);
};

// Create a CompositorFrame suitable to send over IPC.
cc::CompositorFrame MakeCompositorFrame() {
  cc::CompositorFrame frame;
  frame.metadata.begin_frame_ack.source_id =
      cc::BeginFrameArgs::kManualSourceId;
  frame.metadata.begin_frame_ack.sequence_number =
      cc::BeginFrameArgs::kStartingFrameNumber;
  frame.metadata.device_scale_factor = 1.0f;

  auto render_pass = cc::RenderPass::Create();
  render_pass->id = 1;
  render_pass->output_rect = gfx::Rect(100, 100);
  frame.render_pass_list.push_back(std::move(render_pass));

  return frame;
}

// Creates a closure that sets |error_variable| true when run.
base::Closure ConnectionErrorClosure(bool* error_variable) {
  return base::Bind([](bool* error_variable) { *error_variable = true; },
                    error_variable);
}

}  // namespace

class OffscreenCanvasProviderImplTest : public testing::Test {
 public:
  OffscreenCanvasProviderImpl* provider() { return provider_.get(); }

  // Gets the OffscreenCanvasSurfaceImpl for |frame_sink_id| or null if it
  // it doesn't exist.
  OffscreenCanvasSurfaceImpl* GetOffscreenCanvasSurface(
      const cc::FrameSinkId& frame_sink_id) {
    auto iter = provider_->canvas_map_.find(frame_sink_id);
    if (iter == provider_->canvas_map_.end())
      return nullptr;
    return iter->second.get();
  }

  // Gets list of FrameSinkId for all offscreen canvases.
  std::vector<cc::FrameSinkId> GetAllCanvases() {
    std::vector<cc::FrameSinkId> frame_sink_ids;
    for (auto& map_entry : provider_->canvas_map_)
      frame_sink_ids.push_back(map_entry.second->frame_sink_id());
    std::sort(frame_sink_ids.begin(), frame_sink_ids.end());
    return frame_sink_ids;
  }

  void DeleteOffscreenCanvasProviderImpl() { provider_.reset(); }

  void RunUntilIdle() { base::RunLoop().RunUntilIdle(); }

 protected:
  void SetUp() override {
#if !defined(OS_ANDROID)
    ImageTransportFactory::InitializeForUnitTests(
        std::unique_ptr<ImageTransportFactory>(
            new NoTransportImageTransportFactory));
    ImageTransportFactory::GetInstance()
        ->GetFrameSinkManagerHost()
        ->ConnectToFrameSinkManager();
#endif
    provider_ =
        base::MakeUnique<OffscreenCanvasProviderImpl>(kRendererClientId);
  }
  void TearDown() override {
    provider_.reset();
#if !defined(OS_ANDROID)
    ImageTransportFactory::Terminate();
#endif
  }

 private:
  base::MessageLoop message_loop_;
  std::unique_ptr<OffscreenCanvasProviderImpl> provider_;
};

// Mimics the workflow of OffscreenCanvas.commit() on renderer process.
TEST_F(OffscreenCanvasProviderImplTest,
       SingleHTMLCanvasElementTransferToOffscreen) {
  // Mimic connection from the renderer main thread to browser.
  StubOffscreenCanvasSurfaceClient surface_client;
  blink::mojom::OffscreenCanvasSurfacePtr surface;
  provider()->CreateOffscreenCanvasSurface(kFrameSinkParent, kFrameSinkA,
                                           surface_client.GetInterfacePtr(),
                                           mojo::MakeRequest(&surface));

  OffscreenCanvasSurfaceImpl* surface_impl =
      GetOffscreenCanvasSurface(kFrameSinkA);

  // There should be a single OffscreenCanvasSurfaceImpl and it should have the
  // provided FrameSinkId and parent FrameSinkId.
  EXPECT_EQ(kFrameSinkA, surface_impl->frame_sink_id());
  EXPECT_EQ(kFrameSinkParent, surface_impl->parent_frame_sink_id());
  EXPECT_THAT(GetAllCanvases(), ElementsAre(kFrameSinkA));

  // Mimic connection from the renderer main or worker thread to browser.
  cc::mojom::MojoCompositorFrameSinkPtr compositor_frame_sink;
  StubCompositorFrameSinkClient compositor_frame_sink_client;
  provider()->CreateCompositorFrameSink(
      kFrameSinkA, compositor_frame_sink_client.GetInterfacePtr(),
      mojo::MakeRequest(&compositor_frame_sink));

  // Renderer submits a CompositorFrame with |local_id|.
  const cc::LocalSurfaceId local_id(1, base::UnguessableToken::Create());
  compositor_frame_sink->SubmitCompositorFrame(local_id, MakeCompositorFrame());

  RunUntilIdle();

  // OffscreenCanvasSurfaceImpl in browser should have LocalSurfaceId that was
  // submitted with the CompositorFrame.
  EXPECT_EQ(local_id, surface_impl->local_surface_id());

  // OffscreenCanvasSurfaceClient in the renderer should get the new SurfaceId
  // including the |local_id|.
  const auto& surface_info = surface_client.GetLastSurfaceInfo();
  EXPECT_EQ(kFrameSinkA, surface_info.id().frame_sink_id());
  EXPECT_EQ(local_id, surface_info.id().local_surface_id());
}

// Check that renderer closing the mojom::OffscreenCanvasSurface connection
// destroys the OffscreenCanvasSurfaceImpl in browser.
TEST_F(OffscreenCanvasProviderImplTest, ClientClosesConnection) {
  StubOffscreenCanvasSurfaceClient surface_client;
  blink::mojom::OffscreenCanvasSurfacePtr surface;
  provider()->CreateOffscreenCanvasSurface(kFrameSinkParent, kFrameSinkA,
                                           surface_client.GetInterfacePtr(),
                                           mojo::MakeRequest(&surface));

  RunUntilIdle();

  EXPECT_THAT(GetAllCanvases(), ElementsAre(kFrameSinkA));

  // Mimic closing the connection from the renderer.
  surface.reset();

  RunUntilIdle();

  // The renderer closing the connection should destroy the
  // OffscreenCanvasSurfaceImpl.
  EXPECT_THAT(GetAllCanvases(), IsEmpty());
}

// Check that destroying OffscreenCanvasProviderImpl closes connection to
// renderer.
TEST_F(OffscreenCanvasProviderImplTest, ProviderClosesConnections) {
  StubOffscreenCanvasSurfaceClient surface_client;
  blink::mojom::OffscreenCanvasSurfacePtr surface;
  provider()->CreateOffscreenCanvasSurface(kFrameSinkParent, kFrameSinkA,
                                           surface_client.GetInterfacePtr(),
                                           mojo::MakeRequest(&surface));

  // Observe connection errors on |surface|.
  bool connection_error = false;
  surface.set_connection_error_handler(
      ConnectionErrorClosure(&connection_error));

  RunUntilIdle();

  // There should be a OffscreenCanvasSurfaceImpl and |surface| should be bound.
  EXPECT_THAT(GetAllCanvases(), ElementsAre(kFrameSinkA));
  EXPECT_TRUE(surface.is_bound());
  EXPECT_FALSE(connection_error);

  // Delete OffscreenCanvasProviderImpl before client disconnects.
  DeleteOffscreenCanvasProviderImpl();

  RunUntilIdle();

  // This should destroy the OffscreenCanvasSurfaceImpl and close the connection
  // to |surface| triggering a connection error.
  EXPECT_TRUE(connection_error);
}

// Check that connecting MojoCompositorFrameSink without first making a
// OffscreenCanvasSurface connection fails.
TEST_F(OffscreenCanvasProviderImplTest, ClientConnectionWrongOrder) {
  // Mimic connection from the renderer main or worker thread.
  cc::mojom::MojoCompositorFrameSinkPtr compositor_frame_sink;
  StubCompositorFrameSinkClient compositor_frame_sink_client;
  // Try to connect MojoCompositorFrameSink without first making
  // OffscreenCanvasSurface connection. This should fail.
  provider()->CreateCompositorFrameSink(
      kFrameSinkA, compositor_frame_sink_client.GetInterfacePtr(),
      mojo::MakeRequest(&compositor_frame_sink));

  // Observe connection errors on |compositor_frame_sink|.
  bool connection_error = false;
  compositor_frame_sink.set_connection_error_handler(
      ConnectionErrorClosure(&connection_error));

  RunUntilIdle();

  // The connection for |compositor_frame_sink| will have failed and triggered a
  // connection error.
  EXPECT_TRUE(connection_error);
}

// Check that trying to create an OffscreenCanvasSurfaceImpl with a client id
// that doesn't match the renderer fails.
TEST_F(OffscreenCanvasProviderImplTest, InvalidClientId) {
  const cc::FrameSinkId invalid_frame_sink_id(4, 3);
  EXPECT_NE(kRendererClientId, invalid_frame_sink_id.client_id());

  StubOffscreenCanvasSurfaceClient surface_client;
  blink::mojom::OffscreenCanvasSurfacePtr surface;
  provider()->CreateOffscreenCanvasSurface(
      kFrameSinkParent, invalid_frame_sink_id, surface_client.GetInterfacePtr(),
      mojo::MakeRequest(&surface));

  // Observe connection errors on |surface|.
  bool connection_error = false;
  surface.set_connection_error_handler(
      ConnectionErrorClosure(&connection_error));

  RunUntilIdle();

  // No OffscreenCanvasSurfaceImpl should have been created.
  EXPECT_THAT(GetAllCanvases(), IsEmpty());

  // The connection for |surface| will have failed and triggered a connection
  // error.
  EXPECT_TRUE(connection_error);
}

// Mimic renderer with two offscreen canvases.
TEST_F(OffscreenCanvasProviderImplTest,
       MultiHTMLCanvasElementTransferToOffscreen) {
  StubOffscreenCanvasSurfaceClient surface_client_a;
  blink::mojom::OffscreenCanvasSurfacePtr surface_a;
  provider()->CreateOffscreenCanvasSurface(kFrameSinkParent, kFrameSinkA,
                                           surface_client_a.GetInterfacePtr(),
                                           mojo::MakeRequest(&surface_a));

  StubOffscreenCanvasSurfaceClient surface_client_b;
  blink::mojom::OffscreenCanvasSurfacePtr surface_b;
  provider()->CreateOffscreenCanvasSurface(kFrameSinkParent, kFrameSinkB,
                                           surface_client_b.GetInterfacePtr(),
                                           mojo::MakeRequest(&surface_b));

  RunUntilIdle();

  // There should be two OffscreenCanvasSurfaceImpls created.
  EXPECT_THAT(GetAllCanvases(), ElementsAre(kFrameSinkA, kFrameSinkB));

  // Mimic closing first connection from the renderer.
  surface_a.reset();

  RunUntilIdle();

  EXPECT_THAT(GetAllCanvases(), ElementsAre(kFrameSinkB));

  // Mimic closing second connection from the renderer.
  surface_b.reset();

  RunUntilIdle();

  EXPECT_THAT(GetAllCanvases(), IsEmpty());
}

}  // namespace content