blob: ae96c0a0d546aa49ee6dadd1e6bfa593d42112f6 (
plain)
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
// Copyright 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 "chrome/browser/sync_file_system/sync_status_code.h"
#include "base/logging.h"
#include "third_party/leveldatabase/src/include/leveldb/db.h"
namespace sync_file_system {
const char* SyncStatusCodeToString(SyncStatusCode status) {
switch (status) {
case SYNC_STATUS_OK:
return "OK.";
case SYNC_STATUS_UNKNOWN:
return "Unknown sync status.";
case SYNC_STATUS_FAILED:
return "Failed.";
// PlatformFile related errors.
// TODO(nhiroki): add stringize function for PlatformFileError into base/.
case SYNC_FILE_ERROR_FAILED:
return "File operation failed.";
case SYNC_FILE_ERROR_IN_USE:
return "File currently in use.";
case SYNC_FILE_ERROR_EXISTS:
return "File already exists.";
case SYNC_FILE_ERROR_NOT_FOUND:
return "File not found.";
case SYNC_FILE_ERROR_ACCESS_DENIED:
return "File access denied.";
case SYNC_FILE_ERROR_TOO_MANY_OPENED:
return "Too many files open.";
case SYNC_FILE_ERROR_NO_MEMORY:
return "Out of memory.";
case SYNC_FILE_ERROR_NO_SPACE:
return "No space left on disk.";
case SYNC_FILE_ERROR_NOT_A_DIRECTORY:
return "Not a directory.";
case SYNC_FILE_ERROR_INVALID_OPERATION:
return "Invalid file operation.";
case SYNC_FILE_ERROR_SECURITY:
return "Security error.";
case SYNC_FILE_ERROR_ABORT:
return "File operation aborted.";
case SYNC_FILE_ERROR_NOT_A_FILE:
return "Not a file.";
case SYNC_FILE_ERROR_NOT_EMPTY:
return "File not empty.";
case SYNC_FILE_ERROR_INVALID_URL:
return "Invalid URL.";
case SYNC_FILE_ERROR_IO:
return "OS or hardware error.";
// Database related errors.
case SYNC_DATABASE_ERROR_NOT_FOUND:
return "Database not found.";
case SYNC_DATABASE_ERROR_CORRUPTION:
return "Database was corrupted.";
case SYNC_DATABASE_ERROR_IO_ERROR:
return "Database I/O error.";
case SYNC_DATABASE_ERROR_FAILED:
return "Database operation failed.";
// Sync specific status code.
case SYNC_STATUS_FILE_BUSY:
return "Sync: file is busy.";
case SYNC_STATUS_HAS_CONFLICT:
return "Sync: file has conflict.";
case SYNC_STATUS_NO_CONFLICT:
return "Sync: file has no conflict.";
case SYNC_STATUS_ABORT:
return "Sync: operation aborted.";
case SYNC_STATUS_NO_CHANGE_TO_SYNC:
return "Sync: no change to synchronize.";
case SYNC_STATUS_SERVICE_TEMPORARILY_UNAVAILABLE:
return "Sync: service is temporarily unavailable.";
case SYNC_STATUS_NETWORK_ERROR:
return "Sync: network error.";
case SYNC_STATUS_AUTHENTICATION_FAILED:
return "Sync: authentication failed.";
case SYNC_STATUS_UNKNOWN_ORIGIN:
return "Sync: unknown origin.";
case SYNC_STATUS_NOT_MODIFIED:
return "Sync: file not modified.";
case SYNC_STATUS_SYNC_DISABLED:
return "Sync: sync is disabled.";
case SYNC_STATUS_ACCESS_FORBIDDEN:
return "Sync: service access forbidden.";
case SYNC_STATUS_RETRY:
return "Sync: retry the operation.";
}
NOTREACHED();
return "Unknown error.";
}
SyncStatusCode LevelDBStatusToSyncStatusCode(const leveldb::Status& status) {
if (status.ok())
return SYNC_STATUS_OK;
else if (status.IsNotFound())
return SYNC_DATABASE_ERROR_NOT_FOUND;
else if (status.IsCorruption())
return SYNC_DATABASE_ERROR_CORRUPTION;
else if (status.IsIOError())
return SYNC_DATABASE_ERROR_IO_ERROR;
else
return SYNC_DATABASE_ERROR_FAILED;
}
SyncStatusCode PlatformFileErrorToSyncStatusCode(
base::PlatformFileError file_error) {
switch (file_error) {
case base::PLATFORM_FILE_OK:
return SYNC_STATUS_OK;
case base::PLATFORM_FILE_ERROR_FAILED:
return SYNC_FILE_ERROR_FAILED;
case base::PLATFORM_FILE_ERROR_IN_USE:
return SYNC_FILE_ERROR_IN_USE;
case base::PLATFORM_FILE_ERROR_EXISTS:
return SYNC_FILE_ERROR_EXISTS;
case base::PLATFORM_FILE_ERROR_NOT_FOUND:
return SYNC_FILE_ERROR_NOT_FOUND;
case base::PLATFORM_FILE_ERROR_ACCESS_DENIED:
return SYNC_FILE_ERROR_ACCESS_DENIED;
case base::PLATFORM_FILE_ERROR_TOO_MANY_OPENED:
return SYNC_FILE_ERROR_TOO_MANY_OPENED;
case base::PLATFORM_FILE_ERROR_NO_MEMORY:
return SYNC_FILE_ERROR_NO_MEMORY;
case base::PLATFORM_FILE_ERROR_NO_SPACE:
return SYNC_FILE_ERROR_NO_SPACE;
case base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY:
return SYNC_FILE_ERROR_NOT_A_DIRECTORY;
case base::PLATFORM_FILE_ERROR_INVALID_OPERATION:
return SYNC_FILE_ERROR_INVALID_OPERATION;
case base::PLATFORM_FILE_ERROR_SECURITY:
return SYNC_FILE_ERROR_SECURITY;
case base::PLATFORM_FILE_ERROR_ABORT:
return SYNC_FILE_ERROR_ABORT;
case base::PLATFORM_FILE_ERROR_NOT_A_FILE:
return SYNC_FILE_ERROR_NOT_A_FILE;
case base::PLATFORM_FILE_ERROR_NOT_EMPTY:
return SYNC_FILE_ERROR_NOT_EMPTY;
case base::PLATFORM_FILE_ERROR_INVALID_URL:
return SYNC_FILE_ERROR_INVALID_URL;
case base::PLATFORM_FILE_ERROR_IO:
return SYNC_FILE_ERROR_IO;
case base::PLATFORM_FILE_ERROR_MAX:
NOTREACHED();
return SYNC_FILE_ERROR_FAILED;
}
// Return the value as is, so the value converted by
// SyncStatusCodeToPlatformFileError could be restored.
return static_cast<SyncStatusCode>(file_error);
}
base::PlatformFileError SyncStatusCodeToPlatformFileError(
SyncStatusCode status) {
switch (status) {
case SYNC_STATUS_OK:
return base::PLATFORM_FILE_OK;
case SYNC_FILE_ERROR_FAILED:
return base::PLATFORM_FILE_ERROR_FAILED;
case SYNC_FILE_ERROR_IN_USE:
return base::PLATFORM_FILE_ERROR_IN_USE;
case SYNC_FILE_ERROR_EXISTS:
return base::PLATFORM_FILE_ERROR_EXISTS;
case SYNC_FILE_ERROR_NOT_FOUND:
return base::PLATFORM_FILE_ERROR_NOT_FOUND;
case SYNC_FILE_ERROR_ACCESS_DENIED:
return base::PLATFORM_FILE_ERROR_ACCESS_DENIED;
case SYNC_FILE_ERROR_TOO_MANY_OPENED:
return base::PLATFORM_FILE_ERROR_TOO_MANY_OPENED;
case SYNC_FILE_ERROR_NO_MEMORY:
return base::PLATFORM_FILE_ERROR_NO_MEMORY;
case SYNC_FILE_ERROR_NO_SPACE:
return base::PLATFORM_FILE_ERROR_NO_SPACE;
case SYNC_FILE_ERROR_NOT_A_DIRECTORY:
return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
case SYNC_FILE_ERROR_INVALID_OPERATION:
return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
case SYNC_FILE_ERROR_SECURITY:
return base::PLATFORM_FILE_ERROR_SECURITY;
case SYNC_FILE_ERROR_ABORT:
return base::PLATFORM_FILE_ERROR_ABORT;
case SYNC_FILE_ERROR_NOT_A_FILE:
return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
case SYNC_FILE_ERROR_NOT_EMPTY:
return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
case SYNC_FILE_ERROR_INVALID_URL:
return base::PLATFORM_FILE_ERROR_INVALID_URL;
case SYNC_FILE_ERROR_IO:
return base::PLATFORM_FILE_ERROR_IO;
default:
// Return the value as is, so that caller may be able to
// restore the information.
return static_cast<base::PlatformFileError>(status);
}
}
} // namespace sync_file_system
|
