// Copyright 2018 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 "chrome/browser/offline_pages/offline_page_url_loader.h"

#include "base/bind.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/threading/sequenced_task_runner_handle.h"
#include "chrome/browser/offline_pages/offline_page_utils.h"
#include "chrome/browser/renderer_host/chrome_navigation_ui_data.h"
#include "components/offline_pages/core/offline_page_item.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/web_contents.h"
#include "content/public/common/previews_state.h"
#include "mojo/public/cpp/system/simple_watcher.h"
#include "net/base/io_buffer.h"
#include "net/url_request/url_request.h"
#include "services/network/public/cpp/resource_request.h"

namespace offline_pages {

namespace {

constexpr size_t kBufferSize = 4096;

content::WebContents* GetWebContents(int frame_tree_node_id) {
  return content::WebContents::FromFrameTreeNodeId(frame_tree_node_id);
}

bool GetTabId(content::WebContents* web_contents, int* tab_id) {
  return OfflinePageUtils::GetTabId(web_contents, tab_id);
}

net::RedirectInfo CreateRedirectInfo(const GURL& redirected_url,
                                     int response_code) {
  net::RedirectInfo redirect_info;
  redirect_info.new_url = redirected_url;
  redirect_info.new_referrer_policy = net::URLRequest::NO_REFERRER;
  redirect_info.new_method = "GET";
  redirect_info.status_code = response_code;
  redirect_info.new_site_for_cookies = redirect_info.new_url;
  return redirect_info;
}

bool ShouldCreateLoader(const network::ResourceRequest& resource_request) {
  // Ignore the requests not for the main frame.
  if (resource_request.resource_type != content::RESOURCE_TYPE_MAIN_FRAME)
    return false;

  // Ignore non-http/https requests.
  if (!resource_request.url.SchemeIsHTTPOrHTTPS())
    return false;

  // Ignore requests other than GET.
  if (resource_request.method != "GET")
    return false;

  return true;
}

}  // namespace

// static
std::unique_ptr<OfflinePageURLLoader> OfflinePageURLLoader::Create(
    content::NavigationUIData* navigation_ui_data,
    int frame_tree_node_id,
    const network::ResourceRequest& tentative_resource_request,
    content::URLLoaderRequestInterceptor::LoaderCallback callback) {
  if (ShouldCreateLoader(tentative_resource_request)) {
    return base::WrapUnique(new OfflinePageURLLoader(
        navigation_ui_data, frame_tree_node_id, tentative_resource_request,
        std::move(callback)));
  }

  std::move(callback).Run({});
  return nullptr;
}

OfflinePageURLLoader::OfflinePageURLLoader(
    content::NavigationUIData* navigation_ui_data,
    int frame_tree_node_id,
    const network::ResourceRequest& tentative_resource_request,
    content::URLLoaderRequestInterceptor::LoaderCallback callback)
    : navigation_ui_data_(navigation_ui_data),
      frame_tree_node_id_(frame_tree_node_id),
      transition_type_(tentative_resource_request.transition_type),
      loader_callback_(std::move(callback)),
      binding_(this),
      is_offline_preview_allowed_(tentative_resource_request.previews_state &
                                  content::OFFLINE_PAGE_ON),
      weak_ptr_factory_(this) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);

  // TODO(crbug.com/876527): Figure out how offline page interception should
  // interact with URLLoaderThrottles. It might be incorrect to use
  // |tentative_resource_request.headers| here, since throttles can rewrite
  // headers between now and when the request handler passed to
  // |loader_callback_| is invoked.
  request_handler_ = std::make_unique<OfflinePageRequestHandler>(
      tentative_resource_request.url, tentative_resource_request.headers, this);
  request_handler_->Start();
}

OfflinePageURLLoader::~OfflinePageURLLoader() {}

void OfflinePageURLLoader::SetTabIdGetterForTesting(
    OfflinePageRequestHandler::Delegate::TabIdGetter tab_id_getter) {
  tab_id_getter_ = tab_id_getter;
}

void OfflinePageURLLoader::FollowRedirect(
    const std::vector<std::string>& removed_headers,
    const net::HttpRequestHeaders& modified_headers,
    const base::Optional<GURL>& new_url) {
  NOTREACHED();
}

void OfflinePageURLLoader::ProceedWithResponse() {
  NOTREACHED();
}

void OfflinePageURLLoader::SetPriority(net::RequestPriority priority,
                                       int32_t intra_priority_value) {
  // Ignore: this class doesn't have a concept of priority.
}

void OfflinePageURLLoader::PauseReadingBodyFromNet() {
  // Ignore: this class doesn't read from network.
}

void OfflinePageURLLoader::ResumeReadingBodyFromNet() {
  // Ignore: this class doesn't read from network.
}

void OfflinePageURLLoader::FallbackToDefault() {
  std::move(loader_callback_).Run({});
}

void OfflinePageURLLoader::NotifyStartError(int error) {
  std::move(loader_callback_)
      .Run(base::BindOnce(&OfflinePageURLLoader::OnReceiveError,
                          weak_ptr_factory_.GetWeakPtr(), error));
}

void OfflinePageURLLoader::NotifyHeadersComplete(int64_t file_size) {
  std::move(loader_callback_)
      .Run(base::BindOnce(&OfflinePageURLLoader::OnReceiveResponse,
                          weak_ptr_factory_.GetWeakPtr(), file_size));
}

void OfflinePageURLLoader::NotifyReadRawDataComplete(int bytes_read) {
  if (bytes_read < 0) {
    // Negative |bytes_read| is net error code.
    Finish(bytes_read);
    return;
  }
  if (bytes_read == 0) {
    // Zero |bytes_read| means reaching EOF.
    Finish(net::OK);
    return;
  }

  bytes_of_raw_data_to_transfer_ = bytes_read;
  write_position_ = 0;

  TransferRawData();
}

void OfflinePageURLLoader::TransferRawData() {
  while (true) {
    DCHECK_GE(bytes_of_raw_data_to_transfer_, write_position_);
    uint32_t write_size =
        static_cast<uint32_t>(bytes_of_raw_data_to_transfer_ - write_position_);
    // If all the read data have been transferred, read more.
    if (write_size == 0) {
      ReadRawData();
      return;
    }

    MojoResult result =
        producer_handle_->WriteData(buffer_->data() + write_position_,
                                    &write_size, MOJO_WRITE_DATA_FLAG_NONE);
    if (result == MOJO_RESULT_SHOULD_WAIT) {
      handle_watcher_->ArmOrNotify();
      return;
    }

    if (result != MOJO_RESULT_OK) {
      Finish(net::ERR_FAILED);
      return;
    }

    write_position_ += write_size;
  }
}

void OfflinePageURLLoader::SetOfflinePageNavigationUIData(
    bool is_offline_page) {
  // This method should be called before the response data is received.
  DCHECK(!binding_.is_bound());

  ChromeNavigationUIData* navigation_data =
      static_cast<ChromeNavigationUIData*>(navigation_ui_data_);
  std::unique_ptr<OfflinePageNavigationUIData> offline_page_data =
      std::make_unique<OfflinePageNavigationUIData>(is_offline_page);
  navigation_data->SetOfflinePageNavigationUIData(std::move(offline_page_data));
}

bool OfflinePageURLLoader::ShouldAllowPreview() const {
  return is_offline_preview_allowed_;
}

int OfflinePageURLLoader::GetPageTransition() const {
  return transition_type_;
}

OfflinePageRequestHandler::Delegate::WebContentsGetter
OfflinePageURLLoader::GetWebContentsGetter() const {
  return base::Bind(&GetWebContents, frame_tree_node_id_);
}

OfflinePageRequestHandler::Delegate::TabIdGetter
OfflinePageURLLoader::GetTabIdGetter() const {
  if (!tab_id_getter_.is_null())
    return tab_id_getter_;
  return base::Bind(&GetTabId);
}

void OfflinePageURLLoader::ReadRawData() {
  int result = request_handler_->ReadRawData(buffer_.get(), kBufferSize);
  // If |result| is not ERR_IO_PENDING, the read data is available immediately.
  // Otherwise, the read is asynchronous and NotifyReadRawDataComplete will
  // be invoked when the read finishes.
  if (result != net::ERR_IO_PENDING)
    NotifyReadRawDataComplete(result);
}

void OfflinePageURLLoader::OnReceiveError(
    int error,
    const network::ResourceRequest& /* resource_request */,
    network::mojom::URLLoaderRequest request,
    network::mojom::URLLoaderClientPtr client) {
  client_ = std::move(client);
  Finish(error);
}

void OfflinePageURLLoader::OnReceiveResponse(
    int64_t file_size,
    const network::ResourceRequest& /* resource_request */,
    network::mojom::URLLoaderRequest request,
    network::mojom::URLLoaderClientPtr client) {
  // TODO(crbug.com/876527): Figure out how offline page interception should
  // interact with URLLoaderThrottles. It might be incorrect to ignore
  // |resource_request| here, since it's the current request after
  // throttles.
  DCHECK(!binding_.is_bound());
  binding_.Bind(std::move(request));
  binding_.set_connection_error_handler(
      base::BindOnce(&OfflinePageURLLoader::OnConnectionError,
                     weak_ptr_factory_.GetWeakPtr()));
  client_ = std::move(client);

  mojo::DataPipe pipe(kBufferSize);
  if (!pipe.consumer_handle.is_valid()) {
    Finish(net::ERR_FAILED);
    return;
  }

  network::ResourceResponseHead response_head;
  response_head.request_start = base::TimeTicks::Now();
  response_head.response_start = response_head.request_start;

  scoped_refptr<net::HttpResponseHeaders> redirect_headers =
      request_handler_->GetRedirectHeaders();
  if (redirect_headers.get()) {
    std::string redirected_url;
    bool is_redirect = redirect_headers->IsRedirect(&redirected_url);
    DCHECK(is_redirect);
    response_head.headers = redirect_headers;
    response_head.encoded_data_length = 0;
    client_->OnReceiveRedirect(
        CreateRedirectInfo(GURL(redirected_url),
                           redirect_headers->response_code()),
        response_head);
    return;
  }

  response_head.mime_type = "multipart/related";
  response_head.charset = "utf-8";
  response_head.content_length = file_size;

  client_->OnReceiveResponse(response_head);
  client_->OnStartLoadingResponseBody(std::move(pipe.consumer_handle));

  producer_handle_ = std::move(pipe.producer_handle);

  handle_watcher_ = std::make_unique<mojo::SimpleWatcher>(
      FROM_HERE, mojo::SimpleWatcher::ArmingPolicy::MANUAL,
      base::SequencedTaskRunnerHandle::Get());
  handle_watcher_->Watch(
      producer_handle_.get(), MOJO_HANDLE_SIGNAL_WRITABLE,
      MOJO_WATCH_CONDITION_SATISFIED,
      base::BindRepeating(&OfflinePageURLLoader::OnHandleReady,
                          weak_ptr_factory_.GetWeakPtr()));

  buffer_ = base::MakeRefCounted<net::IOBuffer>(kBufferSize);
  ReadRawData();
}

void OfflinePageURLLoader::OnHandleReady(
    MojoResult result,
    const mojo::HandleSignalsState& state) {
  if (result != MOJO_RESULT_OK) {
    Finish(net::ERR_FAILED);
    return;
  }
  TransferRawData();
}

void OfflinePageURLLoader::Finish(int error) {
  client_->OnComplete(network::URLLoaderCompletionStatus(error));
  handle_watcher_.reset();
  producer_handle_.reset();
  client_.reset();
  weak_ptr_factory_.InvalidateWeakPtrs();
  MaybeDeleteSelf();
}

void OfflinePageURLLoader::OnConnectionError() {
  binding_.Close();
  client_.reset();
  MaybeDeleteSelf();
}

void OfflinePageURLLoader::MaybeDeleteSelf() {
  if (!binding_.is_bound() && !client_.is_bound())
    delete this;
}

}  // namespace offline_pages