File: file_errors.cc

package info (click to toggle)
chromium 120.0.6099.224-1~deb11u1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye
  • size: 6,112,112 kB
  • sloc: cpp: 32,907,025; ansic: 8,148,123; javascript: 3,679,536; python: 2,031,248; asm: 959,718; java: 804,675; xml: 617,256; sh: 111,417; objc: 100,835; perl: 88,443; cs: 53,032; makefile: 29,579; fortran: 24,137; php: 21,162; tcl: 21,147; sql: 20,809; ruby: 17,735; pascal: 12,864; yacc: 8,045; lisp: 3,388; lex: 1,323; ada: 727; awk: 329; jsp: 267; csh: 117; exp: 43; sed: 37
file content (149 lines) | stat: -rw-r--r-- 4,164 bytes parent folder | download
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
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/drive/file_errors.h"

#include <type_traits>

#include "base/notreached.h"

namespace drive {

std::ostream& operator<<(std::ostream& out, const FileError error) {
  const std::string s = FileErrorToString(error);
  if (!s.empty()) {
    return out << s;
  }

  return out << "FileError("
             << static_cast<std::underlying_type_t<FileError>>(error) << ")";
}

std::string FileErrorToString(FileError error) {
  switch (error) {
#define PRINT(s) \
  case s:        \
    return #s;
    PRINT(FILE_ERROR_OK)
    PRINT(FILE_ERROR_FAILED)
    PRINT(FILE_ERROR_IN_USE)
    PRINT(FILE_ERROR_EXISTS)
    PRINT(FILE_ERROR_NOT_FOUND)
    PRINT(FILE_ERROR_ACCESS_DENIED)
    PRINT(FILE_ERROR_TOO_MANY_OPENED)
    PRINT(FILE_ERROR_NO_MEMORY)
    PRINT(FILE_ERROR_NO_SERVER_SPACE)
    PRINT(FILE_ERROR_NOT_A_DIRECTORY)
    PRINT(FILE_ERROR_INVALID_OPERATION)
    PRINT(FILE_ERROR_SECURITY)
    PRINT(FILE_ERROR_ABORT)
    PRINT(FILE_ERROR_NOT_A_FILE)
    PRINT(FILE_ERROR_NOT_EMPTY)
    PRINT(FILE_ERROR_INVALID_URL)
    PRINT(FILE_ERROR_NO_CONNECTION)
    PRINT(FILE_ERROR_NO_LOCAL_SPACE)
    PRINT(FILE_ERROR_SERVICE_UNAVAILABLE)
    PRINT(FILE_ERROR_OK_WITH_MORE_RESULTS)
#undef PRINT
  }

  NOTREACHED() << "Unexpected FileError "
               << static_cast<std::underlying_type_t<FileError>>(error);
  return "";
}

base::File::Error FileErrorToBaseFileError(FileError error) {
  switch (error) {
    case FILE_ERROR_OK:
    case FILE_ERROR_OK_WITH_MORE_RESULTS:
      return base::File::FILE_OK;

    case FILE_ERROR_FAILED:
      return base::File::FILE_ERROR_FAILED;

    case FILE_ERROR_IN_USE:
      return base::File::FILE_ERROR_IN_USE;

    case FILE_ERROR_EXISTS:
      return base::File::FILE_ERROR_EXISTS;

    case FILE_ERROR_NOT_FOUND:
      return base::File::FILE_ERROR_NOT_FOUND;

    case FILE_ERROR_ACCESS_DENIED:
      return base::File::FILE_ERROR_ACCESS_DENIED;

    case FILE_ERROR_TOO_MANY_OPENED:
      return base::File::FILE_ERROR_TOO_MANY_OPENED;

    case FILE_ERROR_NO_MEMORY:
      return base::File::FILE_ERROR_NO_MEMORY;

    case FILE_ERROR_NO_SERVER_SPACE:
      return base::File::FILE_ERROR_NO_SPACE;

    case FILE_ERROR_NOT_A_DIRECTORY:
      return base::File::FILE_ERROR_NOT_A_DIRECTORY;

    case FILE_ERROR_INVALID_OPERATION:
      return base::File::FILE_ERROR_INVALID_OPERATION;

    case FILE_ERROR_SECURITY:
      return base::File::FILE_ERROR_SECURITY;

    case FILE_ERROR_ABORT:
      return base::File::FILE_ERROR_ABORT;

    case FILE_ERROR_NOT_A_FILE:
      return base::File::FILE_ERROR_NOT_A_FILE;

    case FILE_ERROR_NOT_EMPTY:
      return base::File::FILE_ERROR_NOT_EMPTY;

    case FILE_ERROR_INVALID_URL:
      return base::File::FILE_ERROR_INVALID_URL;

    case FILE_ERROR_NO_CONNECTION:
      return base::File::FILE_ERROR_FAILED;

    case FILE_ERROR_NO_LOCAL_SPACE:
      return base::File::FILE_ERROR_FAILED;

    case FILE_ERROR_SERVICE_UNAVAILABLE:
      return base::File::FILE_ERROR_FAILED;
  }

  NOTREACHED();
  return base::File::FILE_ERROR_FAILED;
}

FileError GDataToFileError(google_apis::ApiErrorCode status) {
  switch (status) {
    case google_apis::HTTP_SUCCESS:
    case google_apis::HTTP_CREATED:
    case google_apis::HTTP_NO_CONTENT:
      return FILE_ERROR_OK;
    case google_apis::HTTP_UNAUTHORIZED:
    case google_apis::HTTP_FORBIDDEN:
      return FILE_ERROR_ACCESS_DENIED;
    case google_apis::HTTP_NOT_FOUND:
    case google_apis::HTTP_GONE:
      return FILE_ERROR_NOT_FOUND;
    case google_apis::HTTP_INTERNAL_SERVER_ERROR:
    case google_apis::HTTP_SERVICE_UNAVAILABLE:
      return FILE_ERROR_SERVICE_UNAVAILABLE;
    case google_apis::HTTP_NOT_IMPLEMENTED:
      return FILE_ERROR_INVALID_OPERATION;
    case google_apis::CANCELLED:
      return FILE_ERROR_ABORT;
    case google_apis::NO_CONNECTION:
      return FILE_ERROR_NO_CONNECTION;
    case google_apis::DRIVE_NO_SPACE:
      return FILE_ERROR_NO_SERVER_SPACE;
    default:
      return FILE_ERROR_FAILED;
  }
}

}  // namespace drive