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
|
// Copyright (c) 2009 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 "base/linux_util.h"
#include <stdlib.h>
#include <vector>
#include "base/command_line.h"
#include "base/process_util.h"
#include "base/string_util.h"
namespace {
class EnvironmentVariableGetterImpl
: public base::EnvironmentVariableGetter {
public:
virtual bool Getenv(const char* variable_name, std::string* result) {
const char* env_value = ::getenv(variable_name);
if (env_value) {
// Note that the variable may be defined but empty.
*result = env_value;
return true;
}
// Some commonly used variable names are uppercase while others
// are lowercase, which is inconsistent. Let's try to be helpful
// and look for a variable name with the reverse case.
char first_char = variable_name[0];
std::string alternate_case_var;
if (first_char >= 'a' && first_char <= 'z')
alternate_case_var = StringToUpperASCII(std::string(variable_name));
else if (first_char >= 'A' && first_char <= 'Z')
alternate_case_var = StringToLowerASCII(std::string(variable_name));
else
return false;
env_value = ::getenv(alternate_case_var.c_str());
if (env_value) {
*result = env_value;
return true;
}
return false;
}
};
} // anonymous namespace
namespace base {
uint8_t* BGRAToRGBA(const uint8_t* pixels, int width, int height, int stride) {
if (stride == 0)
stride = width * 4;
uint8_t* new_pixels = static_cast<uint8_t*>(malloc(height * stride));
// We have to copy the pixels and swap from BGRA to RGBA.
for (int i = 0; i < height; ++i) {
for (int j = 0; j < width; ++j) {
int idx = i * stride + j * 4;
new_pixels[idx] = pixels[idx + 2];
new_pixels[idx + 1] = pixels[idx + 1];
new_pixels[idx + 2] = pixels[idx];
new_pixels[idx + 3] = pixels[idx + 3];
}
}
return new_pixels;
}
// We use this static string to hold the Linux distro info. If we
// crash, the crash handler code will send this in the crash dump.
std::string linux_distro = "Unknown";
std::string GetLinuxDistro() {
static bool checked_distro = false;
if (!checked_distro) {
std::vector<std::string> argv;
argv.push_back("lsb_release");
argv.push_back("-d");
std::string output;
base::GetAppOutput(CommandLine(argv), &output);
if (output.length() > 0) {
// lsb_release -d should return: Description:<tab>Distro Info
static const std::string field = "Description:\t";
if (output.compare(0, field.length(), field) == 0)
linux_distro = output.substr(field.length());
}
// We do this check only once per process. If it fails, there's
// little reason to believe it will work if we attempt to run
// lsb_release again.
checked_distro = true;
}
return linux_distro;
}
// static
EnvironmentVariableGetter* EnvironmentVariableGetter::Create() {
return new EnvironmentVariableGetterImpl();
}
DesktopEnvironment GetDesktopEnvironment(EnvironmentVariableGetter* env) {
std::string desktop_session;
if (env->Getenv("DESKTOP_SESSION", &desktop_session)) {
if (desktop_session == "gnome")
return DESKTOP_ENVIRONMENT_GNOME;
else if (desktop_session == "kde4")
return DESKTOP_ENVIRONMENT_KDE4;
else if (desktop_session == "kde")
return DESKTOP_ENVIRONMENT_KDE3;
}
// Fall back on some older environment variables.
// Useful particularly in the DESKTOP_SESSION=default case.
std::string dummy;
if (env->Getenv("GNOME_DESKTOP_SESSION_ID", &dummy)) {
return DESKTOP_ENVIRONMENT_GNOME;
} else if (env->Getenv("KDE_FULL_SESSION", &dummy)) {
if (env->Getenv("KDE_SESSION_VERSION", &dummy))
return DESKTOP_ENVIRONMENT_KDE4;
return DESKTOP_ENVIRONMENT_KDE3;
}
return DESKTOP_ENVIRONMENT_OTHER;
}
const char* GetDesktopEnvironmentName(DesktopEnvironment env) {
switch (env) {
case DESKTOP_ENVIRONMENT_OTHER:
return NULL;
case DESKTOP_ENVIRONMENT_GNOME:
return "GNOME";
case DESKTOP_ENVIRONMENT_KDE3:
return "KDE3";
case DESKTOP_ENVIRONMENT_KDE4:
return "KDE4";
}
return NULL;
}
const char* GetDesktopEnvironmentName(EnvironmentVariableGetter* env) {
return GetDesktopEnvironmentName(GetDesktopEnvironment(env));
}
} // namespace base
|
