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
|
// Copyright (c) 2011 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 CHROME_BROWSER_CHROMEOS_VERSION_LOADER_H_
#define CHROME_BROWSER_CHROMEOS_VERSION_LOADER_H_
#include <string>
#include "base/callback.h"
#include "base/gtest_prod_util.h"
#include "chrome/common/cancelable_task_tracker.h"
namespace chromeos {
// ChromeOSVersionLoader loads the version of Chrome OS from the file system.
// Loading is done asynchronously in the blocking thread pool. Once loaded,
// ChromeOSVersionLoader callback to a method of your choice with the version
// (or an empty string if the version couldn't be found).
// To use ChromeOSVersionLoader do the following:
//
// . In your class define a member field of type chromeos::VersionLoader and
// CancelableTaskTracker.
// . Define the callback method, something like:
// void OnGetChromeOSVersion(const std::string& version);
// . When you want the version invoke:
// VersionLoader::GetVersion()
//
// This class also provides the ability to load the bios firmware using
// VersionLoader::GetFirmware()
class VersionLoader {
public:
VersionLoader();
virtual ~VersionLoader();
enum VersionFormat {
VERSION_SHORT,
VERSION_SHORT_WITH_DATE,
VERSION_FULL,
};
// Signature
typedef base::Callback<void(const std::string&)> GetVersionCallback;
typedef base::Callback<void(const std::string&)> GetFirmwareCallback;
// Asynchronously requests the version.
// If |full_version| is true version string with extra info is extracted,
// otherwise it's in short format x.x.xx.x.
CancelableTaskTracker::TaskId GetVersion(VersionFormat format,
const GetVersionCallback& callback,
CancelableTaskTracker* tracker);
CancelableTaskTracker::TaskId GetFirmware(const GetFirmwareCallback& callback,
CancelableTaskTracker* tracker);
static const char kFullVersionPrefix[];
static const char kVersionPrefix[];
static const char kFirmwarePrefix[];
private:
FRIEND_TEST_ALL_PREFIXES(VersionLoaderTest, ParseFullVersion);
FRIEND_TEST_ALL_PREFIXES(VersionLoaderTest, ParseVersion);
FRIEND_TEST_ALL_PREFIXES(VersionLoaderTest, ParseFirmware);
// VersionLoader calls into the Backend in the blocking thread pool to load
// and extract the version.
class Backend : public base::RefCountedThreadSafe<Backend> {
public:
Backend() {}
// Calls ParseVersion to get the version # and notifies request.
// This is invoked in the blocking thread pool.
// If |full_version| is true then extra info is passed in version string.
void GetVersion(VersionFormat format, std::string* version);
// Calls ParseFirmware to get the firmware # and notifies request.
// This is invoked in the blocking thread pool.
void GetFirmware(std::string* firmware);
private:
friend class base::RefCountedThreadSafe<Backend>;
~Backend() {}
DISALLOW_COPY_AND_ASSIGN(Backend);
};
// Extracts the version from the file.
// |prefix| specifies what key defines version data.
static std::string ParseVersion(const std::string& contents,
const std::string& prefix);
// Extracts the firmware from the file.
static std::string ParseFirmware(const std::string& contents);
scoped_refptr<Backend> backend_;
DISALLOW_COPY_AND_ASSIGN(VersionLoader);
};
} // namespace chromeos
#endif // CHROME_BROWSER_CHROMEOS_VERSION_LOADER_H_
|
