blob: 2104aafa32d0dc4315fec17bc3726d320b8e9e37 [file] [log] [blame]
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef COBALT_LOADER_FILE_FETCHER_H_
#define COBALT_LOADER_FILE_FETCHER_H_
#include <limits>
#include <vector>
#include "base/compiler_specific.h"
#include "base/file_path.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/message_loop_proxy.h"
#include "base/platform_file.h"
#include "base/threading/thread_checker.h"
#include "cobalt/loader/fetcher.h"
namespace cobalt {
namespace loader {
// FileFetcher is for fetching data from files on local disk. The file path that
// is passed into the constructor shouldn't include the root directory,
// e.g. it could be "cobalt/loader/testdata/...".
class FileFetcher : public Fetcher {
public:
struct Options {
public:
Options()
: buffer_size(kDefaultBufferSize),
start_offset(0),
bytes_to_read(std::numeric_limits<int64>::max()),
message_loop_proxy(base::MessageLoopProxy::current()) {}
int32 buffer_size;
int64 start_offset;
int64 bytes_to_read;
scoped_refptr<base::MessageLoopProxy> message_loop_proxy;
FilePath extra_search_dir;
};
FileFetcher(const FilePath& file_path, Handler* handler,
const Options& options);
~FileFetcher() OVERRIDE;
// This function is used for binding callback for creating FileFetcher.
static scoped_ptr<Fetcher> Create(const FilePath& file_path,
const Options& options, Handler* handler) {
return scoped_ptr<Fetcher>(new FileFetcher(file_path, handler, options));
}
private:
// Default size of the buffer that FileFetcher will use to load data.
static const int32 kDefaultBufferSize = 64 * 1024;
// Builds the search path list, including an optional extra directory.
void BuildSearchPath(const FilePath& extra_search_dir);
// Tries opening a file using the current entry in the seach path.
void TryFileOpen();
void ReadNextChunk();
void CloseFile();
const char* PlatformFileErrorToString(base::PlatformFileError error);
// Callbacks for FileUtilProxy functions.
void DidCreateOrOpen(base::PlatformFileError error,
base::PassPlatformFile file, bool created);
void DidRead(base::PlatformFileError error, const char* data,
int num_bytes_read);
// Thread checker ensures all calls to the FileFetcher are made from the same
// thread that it is created in.
base::ThreadChecker thread_checker_;
// Size of the buffer that FileFetcher will use to load data.
int32 buffer_size_;
// Handle of the input file.
base::PlatformFile file_;
// Current offset in the input file.
int64 file_offset_;
// How many bytes we are going to read.
int64 bytes_left_to_read_;
// Message loop that is used for actual IO operations in FileUtilProxy.
scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
// Relative (to the current search path entry) file path.
FilePath file_path_;
// Paths to search for files. When a file is to be fetched, the fetcher will
// look at each path in here until the file is found or the end is reached.
std::vector<FilePath> search_path_;
// Used internally to support callbacks with weak references to self.
base::WeakPtrFactory<FileFetcher> weak_ptr_factory_;
// Current iterator into the search path vector.
std::vector<FilePath>::const_iterator curr_search_path_iter_;
};
} // namespace loader
} // namespace cobalt
#endif // COBALT_LOADER_FILE_FETCHER_H_