Remove all //blimp code.

blimp/test/fake_engine/fake_engine_app_tests.cc

-// Copyright 2016 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 "blimp/test/fake_engine/fake_engine.h"
-
-#include <fcntl.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-
-#include "base/command_line.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/launcher/unit_test_launcher.h"
-#include "base/test/test_suite.h"
-#include "blimp/test/fake_engine/proto/engine.grpc.pb.h"
-#include "blimp/test/fake_engine/proto/lifetime.grpc.pb.h"
-#include "blimp/test/fake_engine/proto/logging.grpc.pb.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/grpc/include/grpc++/create_channel_posix.h"
-#include "third_party/grpc/include/grpc++/grpc++.h"
-#include "third_party/grpc/include/grpc++/server_posix.h"
-
-using ::testing::_;
-
-namespace blimp {
-
-namespace {
-
-bool SocketPair(int* fd1, int* fd2) {
-  int pipe_fds[2];
-  if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds) != 0) {
-    PLOG(ERROR) << "socketpair()";
-    return false;
-  }
-
-  // Set both ends to be non-blocking.
-  if (fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK) == -1 ||
-      fcntl(pipe_fds[1], F_SETFL, O_NONBLOCK) == -1) {
-    PLOG(ERROR) << "fcntl(O_NONBLOCK)";
-    if (IGNORE_EINTR(close(pipe_fds[0])) < 0)
-      PLOG(ERROR) << "close";
-    if (IGNORE_EINTR(close(pipe_fds[1])) < 0)
-      PLOG(ERROR) << "close";
-    return false;
-  }
-
-  *fd1 = pipe_fds[0];
-  *fd2 = pipe_fds[1];
-
-  return true;
-}
-
-class MockLifetimeService : public Lifetime::Service {
- public:
-  MOCK_METHOD3(EngineReady, grpc::Status(
-      grpc::ServerContext*, const EngineReadyRequest*, EngineReadyResponse*));
-};
-
-class MockLoggingService : public Logging::Service {
- public:
-  MOCK_METHOD3(Log, grpc::Status(
-      grpc::ServerContext*, const LogRequest*, LogResponse*));
-};
-
-// The FakeEngineAppTest suite sets up a simple interface resembling the
-// Service, which is required by the Fake Engine. This allows testing whether
-// the Fake Engine serves its purpose of simulating the real Engine as spawned
-// by the Service.
-class FakeEngineAppTest : public testing::Test {
- public:
-  FakeEngineAppTest()
-      : engine_ready_(base::WaitableEvent::ResetPolicy::MANUAL,
-                      base::WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- protected:
-  void SetUp() override {
-    CHECK(SocketPair(&rendering_server_connect_fd_, &engine_listen_fd_));
-    CHECK(SocketPair(&rendering_server_listen_fd_, &engine_connect_fd_));
-
-    grpc::ServerBuilder builder;
-    builder.RegisterService(&mock_lifetime_service_);
-    builder.RegisterService(&mock_logging_service_);
-    grpc_server_ = builder.BuildAndStart();
-
-    // TODO(xyzzyz): Remove fcntl when https://github.com/grpc/grpc/pull/8051 is
-    // merged and added to Chromium.
-    int flags = fcntl(rendering_server_listen_fd_, F_GETFL, 0);
-    CHECK_EQ(0, fcntl(rendering_server_listen_fd_, F_SETFL,
-                      flags | O_NONBLOCK));
-
-    grpc::AddInsecureChannelFromFd(grpc_server_.get(),
-                                   rendering_server_listen_fd_);
-  }
-
-  // This function spawns a Fake Engine as a child process, and sets up the file
-  // descriptor mappings for it, resembling the mappings in the Service
-  // environment. It also sets up the handler for the EngineReady function that
-  // will be called by the Fake Engine upon startup.
-  base::Process SpawnEngine() {
-    // Find the path of the Engine.
-    base::CommandLine current_cmd = *base::CommandLine::ForCurrentProcess();
-    base::FilePath current_program_path = base::MakeAbsoluteFilePath(
-        current_cmd.GetProgram());
-    base::FilePath current_dir = current_program_path.DirName();
-    base::FilePath fake_engine_path = current_dir.Append("fake_engine_app");
-
-    base::CommandLine engine_cmd(fake_engine_path);
-
-    base::LaunchOptions options;
-    base::FileHandleMappingVector fds_to_remap = {
-      { engine_listen_fd_, kEngineListenFd },
-      { engine_connect_fd_, kRenderingServerListenFd }
-    };
-    options.fds_to_remap = &fds_to_remap;
-
-    ON_CALL(mock_lifetime_service_, EngineReady(_, _, _))
-        .WillByDefault(
-            testing::Invoke(this, &FakeEngineAppTest::EngineReadyHandler));
-    return base::LaunchProcess(engine_cmd, options);
-  }
-
-  grpc::Status EngineReadyHandler(
-      grpc::ServerContext*, const EngineReadyRequest*, EngineReadyResponse*) {
-    engine_ready_.Signal();
-    return grpc::Status::OK;
-  }
-
-  bool WaitForEngineReady(base::TimeDelta timeout) {
-    return engine_ready_.TimedWait(timeout);
-  }
-
-  std::unique_ptr<Engine::Stub> GetEngineStub() {
-    CHECK(!engine_channel_);
-    engine_channel_ = grpc::CreateInsecureChannelFromFd(
-        "fake_engine", rendering_server_connect_fd_);
-    CHECK(engine_channel_);
-    return Engine::NewStub(engine_channel_);
-  }
-
- private:
-  int engine_listen_fd_;
-  int rendering_server_connect_fd_;
-
-  int rendering_server_listen_fd_;
-  int engine_connect_fd_;
-
-  std::unique_ptr<grpc::Server> grpc_server_;
-  MockLifetimeService mock_lifetime_service_;
-  MockLoggingService mock_logging_service_;
-
-  std::shared_ptr<grpc::Channel> engine_channel_;
-  base::WaitableEvent engine_ready_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeEngineAppTest);
-};
-
-
-TEST_F(FakeEngineAppTest, Basic) {
-  base::Process engine_process = SpawnEngine();
-  EXPECT_TRUE(WaitForEngineReady(base::TimeDelta::FromSeconds(5)));
-
-  std::unique_ptr<Engine::Stub> engine_stub = GetEngineStub();
-  {
-    CheckHealthRequest request;
-    CheckHealthResponse response;
-
-    grpc::ClientContext context;
-    grpc::Status status = engine_stub->CheckHealth(
-        &context, request, &response);
-    EXPECT_TRUE(status.ok());
-    EXPECT_EQ(response.status(), CheckHealthResponse::OK);
-  }
-
-  {
-    ShutDownRequest request;
-    ShutDownResponse response;
-
-    grpc::ClientContext context;
-    grpc::CompletionQueue cq;
-    // We do async call, as the Fake Engine doesn't send any reply to the
-    // ShutDown RPC, so it makes no sense to wait for it.
-    auto rpc = engine_stub->AsyncShutDown(&context, request, &cq);
-
-    EXPECT_TRUE(engine_process.WaitForExitWithTimeout(
-        base::TimeDelta::FromSeconds(5), nullptr /* exit_code */));
-  }
-}
-
-class FakeEngineTestSuite : public base::TestSuite {
- public:
-  FakeEngineTestSuite(int argc, char** argv) : base::TestSuite(argc, argv) {}
-
- protected:
-  void Initialize() override {
-    base::TestSuite::Initialize();
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(FakeEngineTestSuite);
-};
-
-}  // namespace
-
-}  // namespace blimp
-
-int main(int argc, char** argv) {
-  blimp::FakeEngineTestSuite test_suite(argc, argv);
-  return base::LaunchUnitTests(
-      argc, argv,
-      base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite)));
-}