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
|
// 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.
#include "chrome/browser/chromeos/version_loader.h"
#include <vector>
#include "base/bind.h"
#include "base/file_util.h"
#include "base/files/file_path.h"
#include "base/location.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/sys_info.h"
#include "base/threading/sequenced_worker_pool.h"
#include "base/threading/thread.h"
#include "base/time/time.h"
#include "chrome/browser/browser_process.h"
#include "content/public/browser/browser_thread.h"
using content::BrowserThread;
namespace {
// Beginning of line we look for that gives full version number.
// Format: x.x.xx.x (Developer|Official build extra info) board info
const char kFullVersionKey[] = "CHROMEOS_RELEASE_DESCRIPTION";
// Same but for short version (x.x.xx.x).
const char kVersionKey[] = "CHROMEOS_RELEASE_VERSION";
// Beginning of line we look for that gives the firmware version.
const char kFirmwarePrefix[] = "version";
// File to look for firmware number in.
const char kPathFirmware[] = "/var/log/bios_info.txt";
// Converts const string* to const string&.
void VersionLoaderCallbackHelper(
base::Callback<void(const std::string&)> callback,
const std::string* version) {
callback.Run(*version);
}
} // namespace
namespace chromeos {
VersionLoader::VersionLoader() : backend_(new Backend()) {}
VersionLoader::~VersionLoader() {}
base::CancelableTaskTracker::TaskId VersionLoader::GetVersion(
VersionFormat format,
const GetVersionCallback& callback,
base::CancelableTaskTracker* tracker) {
std::string* version = new std::string();
return tracker->PostTaskAndReply(
BrowserThread::GetBlockingPool(),
FROM_HERE,
base::Bind(&Backend::GetVersion, backend_.get(), format, version),
base::Bind(&VersionLoaderCallbackHelper, callback, base::Owned(version)));
}
base::CancelableTaskTracker::TaskId VersionLoader::GetFirmware(
const GetFirmwareCallback& callback,
base::CancelableTaskTracker* tracker) {
std::string* firmware = new std::string();
return tracker->PostTaskAndReply(
BrowserThread::GetBlockingPool(),
FROM_HERE,
base::Bind(&Backend::GetFirmware, backend_.get(), firmware),
base::Bind(&VersionLoaderCallbackHelper,
callback, base::Owned(firmware)));
}
// static
std::string VersionLoader::ParseFirmware(const std::string& contents) {
// The file contains lines such as:
// vendor | ...
// version | ...
// release_date | ...
// We don't make any assumption that the spaces between "version" and "|" is
// fixed. So we just match kFirmwarePrefix at the start of the line and find
// the first character that is not "|" or space
std::vector<std::string> lines;
base::SplitString(contents, '\n', &lines);
for (size_t i = 0; i < lines.size(); ++i) {
if (StartsWithASCII(lines[i], kFirmwarePrefix, false)) {
std::string str = lines[i].substr(std::string(kFirmwarePrefix).size());
size_t found = str.find_first_not_of("| ");
if (found != std::string::npos)
return str.substr(found);
}
}
return std::string();
}
void VersionLoader::Backend::GetVersion(VersionFormat format,
std::string* version) {
DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
std::string key = (format == VERSION_FULL) ? kFullVersionKey : kVersionKey;
if (!base::SysInfo::GetLsbReleaseValue(key, version)) {
LOG_IF(ERROR, base::SysInfo::IsRunningOnChromeOS())
<< "No LSB version key: " << key;
*version = "0.0.0.0";
}
if (format == VERSION_SHORT_WITH_DATE) {
base::Time::Exploded ctime;
base::SysInfo::GetLsbReleaseTime().UTCExplode(&ctime);
*version += base::StringPrintf("-%02u.%02u.%02u",
ctime.year % 100,
ctime.month,
ctime.day_of_month);
}
}
void VersionLoader::Backend::GetFirmware(std::string* firmware) {
DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
std::string contents;
const base::FilePath file_path(kPathFirmware);
if (base::ReadFileToString(file_path, &contents)) {
*firmware = ParseFirmware(contents);
}
}
} // namespace chromeos
|
