1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
// Copyright (c) 2013 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/disk_cache/simple/simple_util.h"
#include <limits>
#include "base/file_util.h"
#include "base/format_macros.h"
#include "base/logging.h"
#include "base/sha1.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/threading/thread_restrictions.h"
#include "base/time/time.h"
#include "net/disk_cache/simple/simple_entry_format.h"
namespace {
// Size of the uint64 hash_key number in Hex format in a string.
const size_t kEntryHashKeyAsHexStringSize = 2 * sizeof(uint64);
// TODO(clamy, gavinp): this should go in base
bool GetNanoSecsFromStat(const struct stat& st,
time_t* out_sec,
long* out_nsec) {
#if defined(OS_ANDROID)
*out_sec = st.st_mtime;
*out_nsec = st.st_mtime_nsec;
#elif defined(OS_LINUX)
*out_sec = st.st_mtim.tv_sec;
*out_nsec = st.st_mtim.tv_nsec;
#elif defined(OS_MACOSX) || defined(OS_IOS) || defined(OS_BSD)
*out_sec = st.st_mtimespec.tv_sec;
*out_nsec = st.st_mtimespec.tv_nsec;
#else
return false;
#endif
return true;
}
} // namespace
namespace disk_cache {
namespace simple_util {
std::string ConvertEntryHashKeyToHexString(uint64 hash_key) {
const std::string hash_key_str = base::StringPrintf("%016" PRIx64, hash_key);
DCHECK_EQ(kEntryHashKeyAsHexStringSize, hash_key_str.size());
return hash_key_str;
}
std::string GetEntryHashKeyAsHexString(const std::string& key) {
std::string hash_key_str =
ConvertEntryHashKeyToHexString(GetEntryHashKey(key));
DCHECK_EQ(kEntryHashKeyAsHexStringSize, hash_key_str.size());
return hash_key_str;
}
bool GetEntryHashKeyFromHexString(const base::StringPiece& hash_key,
uint64* hash_key_out) {
if (hash_key.size() != kEntryHashKeyAsHexStringSize) {
return false;
}
return base::HexStringToUInt64(hash_key, hash_key_out);
}
uint64 GetEntryHashKey(const std::string& key) {
union {
unsigned char sha_hash[base::kSHA1Length];
uint64 key_hash;
} u;
base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(key.data()),
key.size(), u.sha_hash);
return u.key_hash;
}
std::string GetFilenameFromEntryHashAndFileIndex(uint64 entry_hash,
int file_index) {
return base::StringPrintf("%016" PRIx64 "_%1d", entry_hash, file_index);
}
std::string GetSparseFilenameFromEntryHash(uint64 entry_hash) {
return base::StringPrintf("%016" PRIx64 "_s", entry_hash);
}
std::string GetFilenameFromKeyAndFileIndex(const std::string& key,
int file_index) {
return GetEntryHashKeyAsHexString(key) +
base::StringPrintf("_%1d", file_index);
}
int32 GetDataSizeFromKeyAndFileSize(const std::string& key, int64 file_size) {
int64 data_size = file_size - key.size() - sizeof(SimpleFileHeader) -
sizeof(SimpleFileEOF);
DCHECK_GE(implicit_cast<int64>(std::numeric_limits<int32>::max()), data_size);
return data_size;
}
int64 GetFileSizeFromKeyAndDataSize(const std::string& key, int32 data_size) {
return data_size + key.size() + sizeof(SimpleFileHeader) +
sizeof(SimpleFileEOF);
}
int GetFileIndexFromStreamIndex(int stream_index) {
return (stream_index == 2) ? 1 : 0;
}
// TODO(clamy, gavinp): this should go in base
bool GetMTime(const base::FilePath& path, base::Time* out_mtime) {
DCHECK(out_mtime);
#if defined(OS_POSIX)
base::ThreadRestrictions::AssertIOAllowed();
struct stat file_stat;
if (stat(path.value().c_str(), &file_stat) != 0)
return false;
time_t sec;
long nsec;
if (GetNanoSecsFromStat(file_stat, &sec, &nsec)) {
int64 usec = (nsec / base::Time::kNanosecondsPerMicrosecond);
*out_mtime = base::Time::FromTimeT(sec)
+ base::TimeDelta::FromMicroseconds(usec);
return true;
}
#endif
base::PlatformFileInfo file_info;
if (!base::GetFileInfo(path, &file_info))
return false;
*out_mtime = file_info.last_modified;
return true;
}
} // namespace simple_backend
} // namespace disk_cache
|
