Skip to content

GitLab

T
tangled
Commit 52272c06 authored by Matt Menke's avatar Matt Menke Committed by Commit Bot
Browse files
Options

Remove URLRequestSimpleJob and URLRangeRequestJob. 

With the removal of URLRequestFileJob and URLRangeRequestJob, these
classes are no longer in use.

Bug: 934009
Change-Id: I68632b3d79609d72762c4fd8a186eac6d5d7c36b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1869726
Commit-Queue: Matt Menke <mmenke@chromium.org>
Reviewed-by: default avatarEric Roman <eroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#709238}
parent 5f66421b
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 528 deletions
net/BUILD.gn
View file @ 52272c06
...@@ -1813,8 +1813,6 @@ component("net") { ...@@ -1813,8 +1813,6 @@ component("net") {
"url_request/url_fetcher_impl.h", "url_request/url_fetcher_impl.h",
"url_request/url_fetcher_response_writer.cc", "url_request/url_fetcher_response_writer.cc",
"url_request/url_fetcher_response_writer.h", "url_request/url_fetcher_response_writer.h",
"url_request/url_range_request_job.cc",
"url_request/url_range_request_job.h",
"url_request/url_request.cc", "url_request/url_request.cc",
"url_request/url_request.h", "url_request/url_request.h",
"url_request/url_request_context.cc", "url_request/url_request_context.cc",
...@@ -1849,8 +1847,6 @@ component("net") { ...@@ -1849,8 +1847,6 @@ component("net") {
"url_request/url_request_netlog_params.h", "url_request/url_request_netlog_params.h",
"url_request/url_request_redirect_job.cc", "url_request/url_request_redirect_job.cc",
"url_request/url_request_redirect_job.h", "url_request/url_request_redirect_job.h",
"url_request/url_request_simple_job.cc",
"url_request/url_request_simple_job.h",
"url_request/url_request_status.cc", "url_request/url_request_status.cc",
"url_request/url_request_status.h", "url_request/url_request_status.h",
"url_request/url_request_test_job.cc", "url_request/url_request_test_job.cc",
...@@ -5714,7 +5710,6 @@ test("net_unittests") { ...@@ -5714,7 +5710,6 @@ test("net_unittests") {
"url_request/url_request_job_factory_impl_unittest.cc", "url_request/url_request_job_factory_impl_unittest.cc",
"url_request/url_request_job_unittest.cc", "url_request/url_request_job_unittest.cc",
"url_request/url_request_quic_unittest.cc", "url_request/url_request_quic_unittest.cc",
"url_request/url_request_simple_job_unittest.cc",
"url_request/url_request_throttler_simulation_unittest.cc", "url_request/url_request_throttler_simulation_unittest.cc",
"url_request/url_request_throttler_test_support.cc", "url_request/url_request_throttler_test_support.cc",
"url_request/url_request_throttler_test_support.h", "url_request/url_request_throttler_test_support.h",
......
net/url_request/url_range_request_job.cc deleted 100644 → 0
View file @ 5f66421b
// Copyright 2014 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 "net/url_request/url_range_request_job.h"
#include "net/base/net_errors.h"
#include "net/http/http_request_headers.h"
#include "net/http/http_util.h"
namespace net {
URLRangeRequestJob::URLRangeRequestJob(URLRequest* request,
NetworkDelegate* delegate)
: URLRequestJob(request, delegate), range_parse_result_(OK) {
}
URLRangeRequestJob::~URLRangeRequestJob() = default;
void URLRangeRequestJob::SetExtraRequestHeaders(
const HttpRequestHeaders& headers) {
std::string range_header;
if (headers.GetHeader(HttpRequestHeaders::kRange, &range_header)) {
if (!HttpUtil::ParseRangeHeader(range_header, &ranges_)) {
range_parse_result_ = ERR_REQUEST_RANGE_NOT_SATISFIABLE;
}
}
}
} // namespace net
net/url_request/url_range_request_job.h deleted 100644 → 0
View file @ 5f66421b
// Copyright 2014 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.
#ifndef NET_URL_REQUEST_URL_RANGE_REQUEST_JOB_H_
#define NET_URL_REQUEST_URL_RANGE_REQUEST_JOB_H_
#include <vector>
#include "net/base/net_export.h"
#include "net/http/http_byte_range.h"
#include "net/url_request/url_request_job.h"
namespace net {
class HttpRequestHeaders;
// URLRequestJob with support for parsing range requests.
// It is up to subclasses to handle the response
// and deal with an errors parsing the range request header.
// This must be done after Start() has been called.
class NET_EXPORT URLRangeRequestJob : public URLRequestJob {
public:
URLRangeRequestJob(URLRequest* request,
NetworkDelegate* delegate);
void SetExtraRequestHeaders(const HttpRequestHeaders& headers) override;
const std::vector<HttpByteRange>& ranges() const { return ranges_; }
int range_parse_result() const { return range_parse_result_; }
protected:
~URLRangeRequestJob() override;
private:
std::vector<HttpByteRange> ranges_;
int range_parse_result_;
};
} // namespace net
#endif // NET_URL_REQUEST_URL_RANGE_REQUEST_JOB_H_
net/url_request/url_request_simple_job.cc deleted 100644 → 0
View file @ 5f66421b
// Copyright (c) 2012 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 "net/url_request/url_request_simple_job.h"
#include <utility>
#include <vector>
#include "base/bind.h"
#include "base/compiler_specific.h"
#include "base/location.h"
#include "base/memory/ref_counted_memory.h"
#include "base/single_thread_task_runner.h"
#include "base/task/post_task.h"
#include "base/threading/thread_task_runner_handle.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
#include "net/http/http_request_headers.h"
#include "net/http/http_util.h"
#include "net/url_request/url_request_status.h"
namespace net {
namespace {
void CopyData(const scoped_refptr<IOBuffer>& buf,
int buf_size,
const scoped_refptr<base::RefCountedMemory>& data,
int64_t data_offset) {
memcpy(buf->data(), data->front() + data_offset, buf_size);
}
} // namespace
URLRequestSimpleJob::URLRequestSimpleJob(URLRequest* request,
NetworkDelegate* network_delegate)
: URLRangeRequestJob(request, network_delegate), next_data_offset_(0) {}
void URLRequestSimpleJob::Start() {
// Start reading asynchronously so that all error reporting and data
// callbacks happen as they would for network requests.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(&URLRequestSimpleJob::StartAsync,
weak_factory_.GetWeakPtr()));
}
void URLRequestSimpleJob::Kill() {
weak_factory_.InvalidateWeakPtrs();
URLRangeRequestJob::Kill();
}
bool URLRequestSimpleJob::GetMimeType(std::string* mime_type) const {
*mime_type = mime_type_;
return true;
}
bool URLRequestSimpleJob::GetCharset(std::string* charset) {
*charset = charset_;
return true;
}
URLRequestSimpleJob::~URLRequestSimpleJob() = default;
int URLRequestSimpleJob::ReadRawData(IOBuffer* buf, int buf_size) {
buf_size = std::min(static_cast<int64_t>(buf_size),
byte_range_.last_byte_position() - next_data_offset_ + 1);
if (buf_size == 0)
return 0;
// Do memory copy asynchronously on a thread that is not the network thread.
// See crbug.com/422489.
base::PostTaskAndReply(
FROM_HERE,
{base::ThreadPool(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
base::BindOnce(&CopyData, base::WrapRefCounted(buf), buf_size, data_,
next_data_offset_),
base::BindOnce(&URLRequestSimpleJob::ReadRawDataComplete,
weak_factory_.GetWeakPtr(), buf_size));
next_data_offset_ += buf_size;
return ERR_IO_PENDING;
}
int URLRequestSimpleJob::GetData(std::string* mime_type,
std::string* charset,
std::string* data,
CompletionOnceCallback callback) const {
NOTREACHED();
return ERR_UNEXPECTED;
}
int URLRequestSimpleJob::GetRefCountedData(
std::string* mime_type,
std::string* charset,
scoped_refptr<base::RefCountedMemory>* data,
CompletionOnceCallback callback) const {
scoped_refptr<base::RefCountedString> str_data(new base::RefCountedString());
int result =
GetData(mime_type, charset, &str_data->data(), std::move(callback));
*data = str_data;
return result;
}
void URLRequestSimpleJob::StartAsync() {
if (!request_)
return;
if (ranges().size() > 1) {
NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED,
ERR_REQUEST_RANGE_NOT_SATISFIABLE));
return;
}
if (!ranges().empty() && range_parse_result() == OK)
byte_range_ = ranges().front();
const int result =
GetRefCountedData(&mime_type_, &charset_, &data_,
base::BindOnce(&URLRequestSimpleJob::OnGetDataCompleted,
weak_factory_.GetWeakPtr()));
if (result != ERR_IO_PENDING)
OnGetDataCompleted(result);
}
void URLRequestSimpleJob::OnGetDataCompleted(int result) {
if (result == OK) {
// Notify that the headers are complete
if (!byte_range_.ComputeBounds(data_->size())) {
NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED,
ERR_REQUEST_RANGE_NOT_SATISFIABLE));
return;
}
next_data_offset_ = byte_range_.first_byte_position();
set_expected_content_size(byte_range_.last_byte_position() -
next_data_offset_ + 1);
NotifyHeadersComplete();
} else {
NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
}
}
} // namespace net
net/url_request/url_request_simple_job.h deleted 100644 → 0
View file @ 5f66421b
// Copyright (c) 2012 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.
#ifndef NET_URL_REQUEST_URL_REQUEST_SIMPLE_JOB_H_
#define NET_URL_REQUEST_URL_REQUEST_SIMPLE_JOB_H_
#include <stdint.h>
#include <string>
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/completion_once_callback.h"
#include "net/base/net_export.h"
#include "net/url_request/url_range_request_job.h"
namespace base {
class RefCountedMemory;
}
namespace net {
class URLRequest;
class NET_EXPORT URLRequestSimpleJob : public URLRangeRequestJob {
public:
URLRequestSimpleJob(URLRequest* request, NetworkDelegate* network_delegate);
void Start() override;
void Kill() override;
int ReadRawData(IOBuffer* buf, int buf_size) override;
bool GetMimeType(std::string* mime_type) const override;
bool GetCharset(std::string* charset) override;
protected:
~URLRequestSimpleJob() override;
// Subclasses must override either GetData or GetRefCountedData to define the
// way response data is determined.
// The return value should be:
// - OK if data is obtained;
// - ERR_IO_PENDING if async processing is needed to finish obtaining data.
// This is the only case when |callback| should be called after
// completion of the operation. In other situations |callback| should
// never be called;
// - any other ERR_* code to indicate an error. This code will be used
// as the error code in the URLRequestStatus when the URLRequest
// is finished.
virtual int GetData(std::string* mime_type,
std::string* charset,
std::string* data,
CompletionOnceCallback callback) const;
// Similar to GetData(), except |*data| can share ownership of the bytes
// instead of copying them into a std::string.
virtual int GetRefCountedData(std::string* mime_type,
std::string* charset,
scoped_refptr<base::RefCountedMemory>* data,
CompletionOnceCallback callback) const;
void StartAsync();
private:
void OnGetDataCompleted(int result);
HttpByteRange byte_range_;
std::string mime_type_;
std::string charset_;
scoped_refptr<base::RefCountedMemory> data_;
int64_t next_data_offset_;
base::WeakPtrFactory<URLRequestSimpleJob> weak_factory_{this};
};
} // namespace net
#endif // NET_URL_REQUEST_URL_REQUEST_SIMPLE_JOB_H_
net/url_request/url_request_simple_job_unittest.cc deleted 100644 → 0
View file @ 5f66421b
// Copyright 2014 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 "net/url_request/url_request_simple_job.h"
#include <memory>
#include <utility>
#include "base/bind_helpers.h"
#include "base/run_loop.h"
#include "base/sequenced_task_runner.h"
#include "base/stl_util.h"
#include "base/strings/string_piece.h"
#include "base/strings/stringprintf.h"
#include "net/base/request_priority.h"
#include "net/test/gtest_util.h"
#include "net/test/test_with_task_environment.h"
#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
#include "net/url_request/url_request_job.h"
#include "net/url_request/url_request_job_factory.h"
#include "net/url_request/url_request_job_factory_impl.h"
#include "net/url_request/url_request_test_util.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using net::test::IsError;
using net::test::IsOk;
namespace net {
namespace {
const char kTestData[] = "Huge data array";
const int kRangeFirstPosition = 5;
const int kRangeLastPosition = 8;
static_assert(kRangeFirstPosition > 0 &&
kRangeFirstPosition < kRangeLastPosition &&
kRangeLastPosition <
static_cast<int>(base::size(kTestData) - 1),
"invalid range");
class MockSimpleJob : public URLRequestSimpleJob {
public:
MockSimpleJob(URLRequest* request,
NetworkDelegate* network_delegate,
base::StringPiece data)
: URLRequestSimpleJob(request, network_delegate),
data_(data.as_string()) {}
protected:
// URLRequestSimpleJob implementation:
int GetData(std::string* mime_type,
std::string* charset,
std::string* data,
CompletionOnceCallback callback) const override {
mime_type->assign("text/plain");
charset->assign("US-ASCII");
data->assign(data_);
return OK;
}
private:
~MockSimpleJob() override = default;
const std::string data_;
DISALLOW_COPY_AND_ASSIGN(MockSimpleJob);
};
class CancelAfterFirstReadURLRequestDelegate : public TestDelegate {
public:
CancelAfterFirstReadURLRequestDelegate() : run_loop_(new base::RunLoop) {}
~CancelAfterFirstReadURLRequestDelegate() override = default;
void OnResponseStarted(URLRequest* request, int net_error) override {
DCHECK_NE(ERR_IO_PENDING, net_error);
// net::TestDelegate will start the first read.
TestDelegate::OnResponseStarted(request, net_error);
request->Cancel();
run_loop_->Quit();
}
void WaitUntilHeadersReceived() const { run_loop_->Run(); }
private:
std::unique_ptr<base::RunLoop> run_loop_;
DISALLOW_COPY_AND_ASSIGN(CancelAfterFirstReadURLRequestDelegate);
};
class SimpleJobProtocolHandler :
public URLRequestJobFactory::ProtocolHandler {
public:
SimpleJobProtocolHandler() = default;
URLRequestJob* MaybeCreateJob(
URLRequest* request,
NetworkDelegate* network_delegate) const override {
if (request->url().spec() == "data:empty")
return new MockSimpleJob(request, network_delegate, "");
return new MockSimpleJob(request, network_delegate, kTestData);
}
~SimpleJobProtocolHandler() override = default;
private:
DISALLOW_COPY_AND_ASSIGN(SimpleJobProtocolHandler);
};
class URLRequestSimpleJobTest : public TestWithTaskEnvironment {
public:
URLRequestSimpleJobTest() : context_(true) {
job_factory_.SetProtocolHandler(
"data", std::make_unique<SimpleJobProtocolHandler>());
context_.set_job_factory(&job_factory_);
context_.Init();
request_ = context_.CreateRequest(GURL("data:test"), DEFAULT_PRIORITY,
&delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
}
void StartRequest(const HttpRequestHeaders* headers) {
if (headers)
request_->SetExtraRequestHeaders(*headers);
request_->Start();
EXPECT_TRUE(request_->is_pending());
delegate_.RunUntilComplete();
EXPECT_FALSE(request_->is_pending());
}
protected:
TestURLRequestContext context_;
URLRequestJobFactoryImpl job_factory_;
TestDelegate delegate_;
std::unique_ptr<URLRequest> request_;
private:
DISALLOW_COPY_AND_ASSIGN(URLRequestSimpleJobTest);
};
} // namespace
TEST_F(URLRequestSimpleJobTest, SimpleRequest) {
StartRequest(nullptr);
EXPECT_THAT(delegate_.request_status(), IsOk());
EXPECT_EQ(kTestData, delegate_.data_received());
}
TEST_F(URLRequestSimpleJobTest, RangeRequest) {
const std::string kExpectedBody = std::string(
kTestData + kRangeFirstPosition, kTestData + kRangeLastPosition + 1);
HttpRequestHeaders headers;
headers.SetHeader(
HttpRequestHeaders::kRange,
HttpByteRange::Bounded(kRangeFirstPosition, kRangeLastPosition)
.GetHeaderValue());
StartRequest(&headers);
EXPECT_THAT(delegate_.request_status(), IsOk());
EXPECT_EQ(kExpectedBody, delegate_.data_received());
}
TEST_F(URLRequestSimpleJobTest, MultipleRangeRequest) {
HttpRequestHeaders headers;
int middle_pos = (kRangeFirstPosition + kRangeLastPosition)/2;
std::string range = base::StringPrintf("bytes=%d-%d,%d-%d",
kRangeFirstPosition,
middle_pos,
middle_pos + 1,
kRangeLastPosition);
headers.SetHeader(HttpRequestHeaders::kRange, range);
StartRequest(&headers);
EXPECT_TRUE(delegate_.request_failed());
EXPECT_EQ(ERR_REQUEST_RANGE_NOT_SATISFIABLE, delegate_.request_status());
}
TEST_F(URLRequestSimpleJobTest, InvalidRangeRequest) {
HttpRequestHeaders headers;
std::string range = base::StringPrintf(
"bytes=%d-%d", kRangeLastPosition, kRangeFirstPosition);
headers.SetHeader(HttpRequestHeaders::kRange, range);
StartRequest(&headers);
EXPECT_THAT(delegate_.request_status(), IsOk());
EXPECT_EQ(kTestData, delegate_.data_received());
}
TEST_F(URLRequestSimpleJobTest, EmptyDataRequest) {
request_ = context_.CreateRequest(GURL("data:empty"), DEFAULT_PRIORITY,
&delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
StartRequest(nullptr);
EXPECT_THAT(delegate_.request_status(), IsOk());
EXPECT_EQ("", delegate_.data_received());
}
TEST_F(URLRequestSimpleJobTest, CancelBeforeResponseStarts) {
request_ = context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY,
&delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
request_->Start();
request_->Cancel();
base::RunLoop().RunUntilIdle();
EXPECT_THAT(delegate_.request_status(), IsError(ERR_ABORTED));
EXPECT_EQ(1, delegate_.response_started_count());
}
TEST_F(URLRequestSimpleJobTest, CancelAfterFirstReadStarted) {
CancelAfterFirstReadURLRequestDelegate cancel_delegate;
request_ =
context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY,
&cancel_delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
request_->Start();
cancel_delegate.WaitUntilHeadersReceived();
base::RunLoop().RunUntilIdle();
EXPECT_THAT(cancel_delegate.request_status(), IsError(ERR_ABORTED));
EXPECT_EQ(1, cancel_delegate.response_started_count());
EXPECT_EQ("", cancel_delegate.data_received());
// Destroy the request so it doesn't outlive its delegate.
request_.reset();
}
} // namespace net
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment