// Copyright 2020 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 "third_party/blink/renderer/platform/loader/fetch/url_loader/worker_main_script_loader.h"

#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "build/build_config.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "mojo/public/cpp/system/data_pipe_utils.h"
#include "net/http/http_util.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/mojom/fetch/fetch_api_request.mojom-blink.h"
#include "third_party/blink/public/mojom/loader/resource_load_info_notifier.mojom.h"
#include "third_party/blink/renderer/platform/loader/fetch/resource_load_observer.h"
#include "third_party/blink/renderer/platform/loader/fetch/resource_loader_options.h"
#include "third_party/blink/renderer/platform/loader/fetch/url_loader/worker_main_script_loader_client.h"
#include "third_party/blink/renderer/platform/loader/testing/mock_fetch_context.h"
#include "third_party/blink/renderer/platform/testing/testing_platform_support.h"

namespace blink {

namespace {

using ::testing::_;

const char kTopLevelScriptURL[] = "https://example.com/worker.js";
const char kHeader[] =
    "HTTP/1.1 200 OK\n"
    "Content-Type: text/javascript\n\n";
const char kFailHeader[] = "HTTP/1.1 404 Not Found\n\n";
const std::string kTopLevelScript = "fetch(\"empty.html\");";

class WorkerMainScriptLoaderTest : public testing::Test {
 public:
  WorkerMainScriptLoaderTest()
      : fake_loader_(pending_remote_loader_.InitWithNewPipeAndPassReceiver()),
        client_(MakeGarbageCollected<TestClient>()) {
    scoped_feature_list_.InitWithFeatureState(
        blink::features::kPlzDedicatedWorker, true);
  }
  ~WorkerMainScriptLoaderTest() override {
    // Forced GC in order to finalize objects depending on MockResourceObserver,
    // see details https://crbug.com/1132634.
    ThreadState::Current()->CollectAllGarbageForTesting();
  }

 protected:
  class TestClient final : public GarbageCollected<TestClient>,
                           public WorkerMainScriptLoaderClient {

   public:
    // Implements WorkerMainScriptLoaderClient.
    void DidReceiveData(base::span<const char> data) override {
      if (!data_)
        data_ = SharedBuffer::Create(data.data(), data.size());
      else
        data_->Append(data.data(), data.size());
    }
    void OnFinishedLoadingWorkerMainScript() override { finished_ = true; }
    void OnFailedLoadingWorkerMainScript() override { failed_ = true; }

    bool LoadingIsFinished() const { return finished_; }
    bool LoadingIsFailed() const { return failed_; }

    SharedBuffer* Data() const { return data_.get(); }

    void Trace(Visitor* visitor) const override {
      visitor->Trace(worker_main_script_loader_);
    }

   private:
    Member<WorkerMainScriptLoader> worker_main_script_loader_;
    scoped_refptr<SharedBuffer> data_;
    bool finished_ = false;
    bool failed_ = false;
  };

  class FakeURLLoader final : public network::mojom::URLLoader {
   public:
    explicit FakeURLLoader(
        mojo::PendingReceiver<network::mojom::URLLoader> url_loader_receiver)
        : receiver_(this, std::move(url_loader_receiver)) {}
    ~FakeURLLoader() override = default;

    FakeURLLoader(const FakeURLLoader&) = delete;
    FakeURLLoader& operator=(const FakeURLLoader&) = delete;

    // network::mojom::URLLoader overrides.
    void FollowRedirect(const std::vector<std::string>&,
                        const net::HttpRequestHeaders&,
                        const net::HttpRequestHeaders&,
                        const base::Optional<GURL>&) override {}
    void SetPriority(net::RequestPriority priority,
                     int32_t intra_priority_value) override {}
    void PauseReadingBodyFromNet() override {}
    void ResumeReadingBodyFromNet() override {}

   private:
    mojo::Receiver<network::mojom::URLLoader> receiver_;
  };

  class FakeResourceLoadInfoNotifier final
      : public blink::mojom::ResourceLoadInfoNotifier {
   public:
    FakeResourceLoadInfoNotifier() = default;

    FakeResourceLoadInfoNotifier(const FakeResourceLoadInfoNotifier&) = delete;
    FakeResourceLoadInfoNotifier& operator=(
        const FakeResourceLoadInfoNotifier&) = delete;

    // blink::mojom::ResourceLoadInfoNotifier overrides.
#if defined(OS_ANDROID)
    void NotifyUpdateUserGestureCarryoverInfo() override {}
#endif
    void NotifyResourceRedirectReceived(
        const net::RedirectInfo& redirect_info,
        network::mojom::URLResponseHeadPtr redirect_response) override {}
    void NotifyResourceResponseReceived(
        int64_t request_id,
        const GURL& final_url,
        network::mojom::URLResponseHeadPtr head,
        network::mojom::RequestDestination request_destination,
        int32_t previews_state) override {}
    void NotifyResourceTransferSizeUpdated(
        int64_t request_id,
        int32_t transfer_size_diff) override {}
    void NotifyResourceLoadCompleted(
        blink::mojom::ResourceLoadInfoPtr resource_load_info,
        const ::network::URLLoaderCompletionStatus& status) override {
      resource_load_info_ = std::move(resource_load_info);
    }
    void NotifyResourceLoadCanceled(int64_t request_id) override {}
    void Clone(mojo::PendingReceiver<blink::mojom::ResourceLoadInfoNotifier>
                   pending_resource_load_info_notifier) override {}

    std::string GetMimeType() { return resource_load_info_->mime_type; }

   private:
    blink::mojom::ResourceLoadInfoPtr resource_load_info_;
  };

  class MockResourceLoadObserver : public ResourceLoadObserver {
   public:
    MOCK_METHOD2(DidStartRequest, void(const FetchParameters&, ResourceType));
    MOCK_METHOD6(WillSendRequest,
                 void(uint64_t identifier,
                      const ResourceRequest&,
                      const ResourceResponse& redirect_response,
                      ResourceType,
                      const FetchInitiatorInfo&,
                      RenderBlockingBehavior));
    MOCK_METHOD3(DidChangePriority,
                 void(uint64_t identifier,
                      ResourceLoadPriority,
                      int intra_priority_value));
    MOCK_METHOD5(DidReceiveResponse,
                 void(uint64_t identifier,
                      const ResourceRequest& request,
                      const ResourceResponse& response,
                      const Resource* resource,
                      ResponseSource));
    MOCK_METHOD2(DidReceiveData,
                 void(uint64_t identifier, base::span<const char> chunk));
    MOCK_METHOD2(DidReceiveTransferSizeUpdate,
                 void(uint64_t identifier, int transfer_size_diff));
    MOCK_METHOD2(DidDownloadToBlob, void(uint64_t identifier, BlobDataHandle*));
    MOCK_METHOD5(DidFinishLoading,
                 void(uint64_t identifier,
                      base::TimeTicks finish_time,
                      int64_t encoded_data_length,
                      int64_t decoded_body_length,
                      bool should_report_corb_blocking));
    MOCK_METHOD5(DidFailLoading,
                 void(const KURL&,
                      uint64_t identifier,
                      const ResourceError&,
                      int64_t encoded_data_length,
                      IsInternalRequest));
    MOCK_METHOD1(EvictFromBackForwardCache,
                 void(blink::mojom::RendererEvictionReason));
  };

  MojoCreateDataPipeOptions CreateDataPipeOptions() {
    MojoCreateDataPipeOptions options;
    options.struct_size = sizeof(MojoCreateDataPipeOptions);
    options.flags = MOJO_CREATE_DATA_PIPE_FLAG_NONE;
    options.element_num_bytes = 1;
    options.capacity_num_bytes = 1024;
    return options;
  }

  std::unique_ptr<WorkerMainScriptLoadParameters> CreateMainScriptLoaderParams(
      const char* header,
      mojo::ScopedDataPipeProducerHandle* body_producer) {
    auto head = network::mojom::URLResponseHead::New();
    head->headers = base::MakeRefCounted<net::HttpResponseHeaders>(
        net::HttpUtil::AssembleRawHeaders(header));
    head->headers->GetMimeType(&head->mime_type);
    network::mojom::URLLoaderClientEndpointsPtr endpoints =
        network::mojom::URLLoaderClientEndpoints::New(
            std::move(pending_remote_loader_),
            loader_client_.BindNewPipeAndPassReceiver());

    std::unique_ptr<WorkerMainScriptLoadParameters>
        worker_main_script_load_params =
            std::make_unique<WorkerMainScriptLoadParameters>();
    worker_main_script_load_params->response_head = std::move(head);
    worker_main_script_load_params->url_loader_client_endpoints =
        std::move(endpoints);
    mojo::ScopedDataPipeConsumerHandle body_consumer;
    MojoCreateDataPipeOptions options = CreateDataPipeOptions();
    EXPECT_EQ(MOJO_RESULT_OK,
              mojo::CreateDataPipe(&options, *body_producer, body_consumer));
    worker_main_script_load_params->response_body = std::move(body_consumer);

    return worker_main_script_load_params;
  }

  WorkerMainScriptLoader* CreateWorkerMainScriptLoaderAndStartLoading(
      std::unique_ptr<WorkerMainScriptLoadParameters>
          worker_main_script_load_params,
      ResourceLoadObserver* observer,
      mojom::ResourceLoadInfoNotifier* resource_load_info_notifier) {
    ResourceRequest request(kTopLevelScriptURL);
    request.SetRequestContext(mojom::blink::RequestContextType::SHARED_WORKER);
    request.SetRequestDestination(
        network::mojom::RequestDestination::kSharedWorker);
    FetchParameters fetch_params(std::move(request),
                                 ResourceLoaderOptions(nullptr /* world */));
    WorkerMainScriptLoader* worker_main_script_loader =
        MakeGarbageCollected<WorkerMainScriptLoader>();
    MockFetchContext* fetch_context = MakeGarbageCollected<MockFetchContext>();
    fetch_context->SetResourceLoadInfoNotifier(resource_load_info_notifier);
    worker_main_script_loader->Start(fetch_params,
                                     std::move(worker_main_script_load_params),
                                     fetch_context, observer, client_);
    return worker_main_script_loader;
  }

  void Complete(int net_error) {
    loader_client_->OnComplete(network::URLLoaderCompletionStatus(net_error));
    base::RunLoop().RunUntilIdle();
  }

 protected:
  base::test::TaskEnvironment task_environment_;

  mojo::PendingRemote<network::mojom::URLLoader> pending_remote_loader_;
  mojo::Remote<network::mojom::URLLoaderClient> loader_client_;
  FakeURLLoader fake_loader_;

  Persistent<TestClient> client_;
  base::test::ScopedFeatureList scoped_feature_list_;
};

TEST_F(WorkerMainScriptLoaderTest, ResponseWithSucessThenOnComplete) {
  mojo::ScopedDataPipeProducerHandle body_producer;
  std::unique_ptr<WorkerMainScriptLoadParameters>
      worker_main_script_load_params =
          CreateMainScriptLoaderParams(kHeader, &body_producer);
  MockResourceLoadObserver* mock_observer =
      MakeGarbageCollected<MockResourceLoadObserver>();
  FakeResourceLoadInfoNotifier fake_resource_load_info_notifier;
  EXPECT_CALL(*mock_observer, WillSendRequest(_, _, _, _, _, _));
  EXPECT_CALL(*mock_observer, DidReceiveResponse(_, _, _, _, _));
  EXPECT_CALL(*mock_observer, DidReceiveData(_, _));
  EXPECT_CALL(*mock_observer, DidFinishLoading(_, _, _, _, _));
  EXPECT_CALL(*mock_observer, DidFailLoading(_, _, _, _, _)).Times(0);
  Persistent<WorkerMainScriptLoader> worker_main_script_loader =
      CreateWorkerMainScriptLoaderAndStartLoading(
          std::move(worker_main_script_load_params), mock_observer,
          &fake_resource_load_info_notifier);
  mojo::BlockingCopyFromString(kTopLevelScript, body_producer);
  body_producer.reset();
  Complete(net::OK);

  EXPECT_TRUE(client_->LoadingIsFinished());
  EXPECT_FALSE(client_->LoadingIsFailed());
  EXPECT_EQ(KURL(kTopLevelScriptURL),
            worker_main_script_loader->GetRequestURL());
  EXPECT_EQ(UTF8Encoding(), worker_main_script_loader->GetScriptEncoding());
  EXPECT_EQ(kTopLevelScript,
            std::string(client_->Data()->Data(), client_->Data()->size()));
  EXPECT_EQ("text/javascript", fake_resource_load_info_notifier.GetMimeType());
}

TEST_F(WorkerMainScriptLoaderTest, ResponseWithFailureThenOnComplete) {
  mojo::ScopedDataPipeProducerHandle body_producer;
  std::unique_ptr<WorkerMainScriptLoadParameters>
      worker_main_script_load_params =
          CreateMainScriptLoaderParams(kFailHeader, &body_producer);
  MockResourceLoadObserver* mock_observer =
      MakeGarbageCollected<MockResourceLoadObserver>();
  FakeResourceLoadInfoNotifier fake_resource_load_info_notifier;
  EXPECT_CALL(*mock_observer, WillSendRequest(_, _, _, _, _, _));
  EXPECT_CALL(*mock_observer, DidReceiveResponse(_, _, _, _, _));
  EXPECT_CALL(*mock_observer, DidFinishLoading(_, _, _, _, _)).Times(0);
  EXPECT_CALL(*mock_observer, DidFailLoading(_, _, _, _, _));
  Persistent<WorkerMainScriptLoader> worker_main_script_loader =
      CreateWorkerMainScriptLoaderAndStartLoading(
          std::move(worker_main_script_load_params), mock_observer,
          &fake_resource_load_info_notifier);
  mojo::BlockingCopyFromString("PAGE NOT FOUND\n", body_producer);
  Complete(net::OK);
  body_producer.reset();

  EXPECT_FALSE(client_->LoadingIsFinished());
  EXPECT_TRUE(client_->LoadingIsFailed());
}

TEST_F(WorkerMainScriptLoaderTest, DisconnectBeforeOnComplete) {
  mojo::ScopedDataPipeProducerHandle body_producer;
  std::unique_ptr<WorkerMainScriptLoadParameters>
      worker_main_script_load_params =
          CreateMainScriptLoaderParams(kHeader, &body_producer);
  MockResourceLoadObserver* mock_observer =
      MakeGarbageCollected<MockResourceLoadObserver>();
  FakeResourceLoadInfoNotifier fake_resource_load_info_notifier;
  EXPECT_CALL(*mock_observer, WillSendRequest(_, _, _, _, _, _));
  EXPECT_CALL(*mock_observer, DidReceiveResponse(_, _, _, _, _));
  EXPECT_CALL(*mock_observer, DidFinishLoading(_, _, _, _, _)).Times(0);
  EXPECT_CALL(*mock_observer, DidFailLoading(_, _, _, _, _));
  Persistent<WorkerMainScriptLoader> worker_main_script_loader =
      CreateWorkerMainScriptLoaderAndStartLoading(
          std::move(worker_main_script_load_params), mock_observer,
          &fake_resource_load_info_notifier);
  loader_client_.reset();
  body_producer.reset();
  base::RunLoop().RunUntilIdle();

  EXPECT_FALSE(client_->LoadingIsFinished());
  EXPECT_TRUE(client_->LoadingIsFailed());
}

TEST_F(WorkerMainScriptLoaderTest, OnCompleteWithError) {
  mojo::ScopedDataPipeProducerHandle body_producer;
  std::unique_ptr<WorkerMainScriptLoadParameters>
      worker_main_script_load_params =
          CreateMainScriptLoaderParams(kHeader, &body_producer);
  MockResourceLoadObserver* mock_observer =
      MakeGarbageCollected<MockResourceLoadObserver>();
  FakeResourceLoadInfoNotifier fake_resource_load_info_notifier;
  EXPECT_CALL(*mock_observer, WillSendRequest(_, _, _, _, _, _));
  EXPECT_CALL(*mock_observer, DidReceiveResponse(_, _, _, _, _));
  EXPECT_CALL(*mock_observer, DidReceiveData(_, _));
  EXPECT_CALL(*mock_observer, DidFinishLoading(_, _, _, _, _)).Times(0);
  EXPECT_CALL(*mock_observer, DidFailLoading(_, _, _, _, _));
  Persistent<WorkerMainScriptLoader> worker_main_script_loader =
      CreateWorkerMainScriptLoaderAndStartLoading(
          std::move(worker_main_script_load_params), mock_observer,
          &fake_resource_load_info_notifier);
  mojo::BlockingCopyFromString(kTopLevelScript, body_producer);
  Complete(net::ERR_FAILED);
  body_producer.reset();

  EXPECT_FALSE(client_->LoadingIsFinished());
  EXPECT_TRUE(client_->LoadingIsFailed());
}

}  // namespace

}  // namespace blink