| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/feedback/feedback_data.h" | |
| 6 | |
| 7 #include "base/file_util.h" | |
| 8 #include "base/json/json_string_value_serializer.h" | |
| 9 #include "base/strings/string_util.h" | |
| 10 #include "base/strings/utf_string_conversions.h" | |
| 11 #include "base/values.h" | |
| 12 #include "chrome/browser/browser_process.h" | |
| 13 #include "chrome/browser/chromeos/settings/cros_settings.h" | |
| 14 #include "chrome/browser/feedback/feedback_util.h" | |
| 15 #include "chrome/browser/feedback/tracing_manager.h" | |
| 16 #include "chrome/browser/profiles/profile_manager.h" | |
| 17 #include "content/public/browser/browser_thread.h" | |
| 18 | |
| 19 #if defined(USE_ASH) | |
| 20 #include "ash/shell.h" | |
| 21 #include "ash/shell_delegate.h" | |
| 22 #endif | |
| 23 | |
| 24 using content::BrowserThread; | |
| 25 | |
| 26 namespace { | |
| 27 | |
| 28 const char kMultilineIndicatorString[] = "<multiline>\n"; | |
| 29 const char kMultilineStartString[] = "---------- START ----------\n"; | |
| 30 const char kMultilineEndString[] = "---------- END ----------\n\n"; | |
| 31 | |
| 32 const size_t kFeedbackMaxLength = 4 * 1024; | |
| 33 const size_t kFeedbackMaxLineCount = 40; | |
| 34 | |
| 35 const char kTraceFilename[] = "tracing.zip\n"; | |
| 36 const char kPerformanceCategoryTag[] = "Performance"; | |
| 37 | |
| 38 const char kZipExt[] = ".zip"; | |
| 39 | |
| 40 const base::FilePath::CharType kLogsFilename[] = | |
| 41 FILE_PATH_LITERAL("system_logs.txt"); | |
| 42 const base::FilePath::CharType kHistogramsFilename[] = | |
| 43 FILE_PATH_LITERAL("histograms.txt"); | |
| 44 | |
| 45 // Converts the system logs into a string that we can compress and send | |
| 46 // with the report. This method only converts those logs that we want in | |
| 47 // the compressed zip file sent with the report, hence it ignores any logs | |
| 48 // below the size threshold of what we want compressed. | |
| 49 std::string LogsToString(const FeedbackData::SystemLogsMap& sys_info) { | |
| 50 std::string syslogs_string; | |
| 51 for (FeedbackData::SystemLogsMap::const_iterator it = sys_info.begin(); | |
| 52 it != sys_info.end(); ++it) { | |
| 53 std::string key = it->first; | |
| 54 std::string value = it->second; | |
| 55 | |
| 56 if (FeedbackData::BelowCompressionThreshold(value)) | |
| 57 continue; | |
| 58 | |
| 59 base::TrimString(key, "\n ", &key); | |
| 60 base::TrimString(value, "\n ", &value); | |
| 61 | |
| 62 if (value.find("\n") != std::string::npos) { | |
| 63 syslogs_string.append( | |
| 64 key + "=" + kMultilineIndicatorString + | |
| 65 kMultilineStartString + | |
| 66 value + "\n" + | |
| 67 kMultilineEndString); | |
| 68 } else { | |
| 69 syslogs_string.append(key + "=" + value + "\n"); | |
| 70 } | |
| 71 } | |
| 72 return syslogs_string; | |
| 73 } | |
| 74 | |
| 75 void ZipFile(const base::FilePath& filename, | |
| 76 const std::string& data, std::string* compressed_data) { | |
| 77 if (!feedback_util::ZipString(filename, data, compressed_data)) | |
| 78 compressed_data->clear(); | |
| 79 } | |
| 80 | |
| 81 void ZipLogs(const FeedbackData::SystemLogsMap& sys_info, | |
| 82 std::string* compressed_logs) { | |
| 83 DCHECK(compressed_logs); | |
| 84 std::string logs_string = LogsToString(sys_info); | |
| 85 if (logs_string.empty() || | |
| 86 !feedback_util::ZipString( | |
| 87 base::FilePath(kLogsFilename), logs_string, compressed_logs)) { | |
| 88 compressed_logs->clear(); | |
| 89 } | |
| 90 } | |
| 91 | |
| 92 void ZipHistograms(const std::string& histograms, | |
| 93 std::string* compressed_histograms) { | |
| 94 DCHECK(compressed_histograms); | |
| 95 if (histograms.empty() || | |
| 96 !feedback_util::ZipString( | |
| 97 base::FilePath(kHistogramsFilename), | |
| 98 histograms, | |
| 99 compressed_histograms)) { | |
| 100 compressed_histograms->clear(); | |
| 101 } | |
| 102 } | |
| 103 | |
| 104 } // namespace | |
| 105 | |
| 106 // static | |
| 107 bool FeedbackData::BelowCompressionThreshold(const std::string& content) { | |
| 108 if (content.length() > kFeedbackMaxLength) | |
| 109 return false; | |
| 110 const size_t line_count = std::count(content.begin(), content.end(), '\n'); | |
| 111 if (line_count > kFeedbackMaxLineCount) | |
| 112 return false; | |
| 113 return true; | |
| 114 } | |
| 115 | |
| 116 FeedbackData::FeedbackData() : profile_(NULL), | |
| 117 trace_id_(0), | |
| 118 feedback_page_data_complete_(false), | |
| 119 syslogs_compression_complete_(false), | |
| 120 histograms_compression_complete_(false), | |
| 121 attached_file_compression_complete_(false), | |
| 122 report_sent_(false) { | |
| 123 } | |
| 124 | |
| 125 FeedbackData::~FeedbackData() { | |
| 126 } | |
| 127 | |
| 128 void FeedbackData::OnFeedbackPageDataComplete() { | |
| 129 feedback_page_data_complete_ = true; | |
| 130 SendReport(); | |
| 131 } | |
| 132 | |
| 133 void FeedbackData::SetAndCompressSystemInfo( | |
| 134 scoped_ptr<FeedbackData::SystemLogsMap> sys_info) { | |
| 135 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 136 | |
| 137 if (trace_id_ != 0) { | |
| 138 TracingManager* manager = TracingManager::Get(); | |
| 139 if (!manager || | |
| 140 !manager->GetTraceData( | |
| 141 trace_id_, | |
| 142 base::Bind(&FeedbackData::OnGetTraceData, this, trace_id_))) { | |
| 143 trace_id_ = 0; | |
| 144 } | |
| 145 } | |
| 146 | |
| 147 sys_info_ = sys_info.Pass(); | |
| 148 if (sys_info_.get()) { | |
| 149 std::string* compressed_logs_ptr = new std::string; | |
| 150 scoped_ptr<std::string> compressed_logs(compressed_logs_ptr); | |
| 151 BrowserThread::PostBlockingPoolTaskAndReply( | |
| 152 FROM_HERE, | |
| 153 base::Bind(&ZipLogs, | |
| 154 *sys_info_, | |
| 155 compressed_logs_ptr), | |
| 156 base::Bind(&FeedbackData::OnCompressLogsComplete, | |
| 157 this, | |
| 158 base::Passed(&compressed_logs))); | |
| 159 } | |
| 160 } | |
| 161 | |
| 162 void FeedbackData::SetAndCompressHistograms( | |
| 163 scoped_ptr<std::string> histograms) { | |
| 164 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 165 | |
| 166 histograms_ = histograms.Pass(); | |
| 167 if (histograms_.get()) { | |
| 168 std::string* compressed_histograms_ptr = new std::string; | |
| 169 scoped_ptr<std::string> compressed_histograms(compressed_histograms_ptr); | |
| 170 BrowserThread::PostBlockingPoolTaskAndReply( | |
| 171 FROM_HERE, | |
| 172 base::Bind(&ZipHistograms, | |
| 173 *histograms_, | |
| 174 compressed_histograms_ptr), | |
| 175 base::Bind(&FeedbackData::OnCompressHistogramsComplete, | |
| 176 this, | |
| 177 base::Passed(&compressed_histograms))); | |
| 178 } | |
| 179 } | |
| 180 | |
| 181 void FeedbackData::AttachAndCompressFileData( | |
| 182 scoped_ptr<std::string> attached_filedata) { | |
| 183 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 184 | |
| 185 attached_filedata_ = attached_filedata.Pass(); | |
| 186 | |
| 187 if (!attached_filename_.empty() && attached_filedata_.get()) { | |
| 188 std::string* compressed_file_ptr = new std::string; | |
| 189 scoped_ptr<std::string> compressed_file(compressed_file_ptr); | |
| 190 #if defined(OS_WIN) | |
| 191 base::FilePath attached_file(base::UTF8ToWide(attached_filename_)); | |
| 192 #else | |
| 193 base::FilePath attached_file(attached_filename_); | |
| 194 #endif | |
| 195 BrowserThread::PostBlockingPoolTaskAndReply( | |
| 196 FROM_HERE, | |
| 197 base::Bind(&ZipFile, | |
| 198 attached_file, | |
| 199 *(attached_filedata_.get()), | |
| 200 compressed_file_ptr), | |
| 201 base::Bind(&FeedbackData::OnCompressFileComplete, | |
| 202 this, | |
| 203 base::Passed(&compressed_file))); | |
| 204 } | |
| 205 } | |
| 206 | |
| 207 void FeedbackData::OnGetTraceData( | |
| 208 int trace_id, | |
| 209 scoped_refptr<base::RefCountedString> trace_data) { | |
| 210 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 211 TracingManager* manager = TracingManager::Get(); | |
| 212 if (manager) | |
| 213 manager->DiscardTraceData(trace_id); | |
| 214 | |
| 215 scoped_ptr<std::string> data(new std::string); | |
| 216 data->swap(trace_data->data()); | |
| 217 | |
| 218 attached_filename_ = kTraceFilename; | |
| 219 attached_filedata_ = data.Pass(); | |
| 220 attached_file_compression_complete_ = true; | |
| 221 trace_id_ = 0; | |
| 222 | |
| 223 set_category_tag(kPerformanceCategoryTag); | |
| 224 | |
| 225 SendReport(); | |
| 226 } | |
| 227 | |
| 228 void FeedbackData::OnCompressLogsComplete( | |
| 229 scoped_ptr<std::string> compressed_logs) { | |
| 230 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 231 | |
| 232 compressed_logs_ = compressed_logs.Pass(); | |
| 233 syslogs_compression_complete_ = true; | |
| 234 | |
| 235 SendReport(); | |
| 236 } | |
| 237 | |
| 238 void FeedbackData::OnCompressHistogramsComplete( | |
| 239 scoped_ptr<std::string> compressed_histograms) { | |
| 240 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 241 | |
| 242 compressed_histograms_ = compressed_histograms.Pass(); | |
| 243 histograms_compression_complete_ = true; | |
| 244 | |
| 245 SendReport(); | |
| 246 } | |
| 247 | |
| 248 void FeedbackData::OnCompressFileComplete( | |
| 249 scoped_ptr<std::string> compressed_file) { | |
| 250 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 251 | |
| 252 if (compressed_file.get()) { | |
| 253 attached_filedata_ = compressed_file.Pass(); | |
| 254 attached_filename_.append(kZipExt); | |
| 255 attached_file_compression_complete_ = true; | |
| 256 } else { | |
| 257 attached_filename_.clear(); | |
| 258 attached_filedata_.reset(NULL); | |
| 259 } | |
| 260 | |
| 261 SendReport(); | |
| 262 } | |
| 263 | |
| 264 bool FeedbackData::IsDataComplete() { | |
| 265 return (!sys_info_.get() || syslogs_compression_complete_) && | |
| 266 (!histograms_.get() || histograms_compression_complete_) && | |
| 267 (!attached_filedata_.get() || attached_file_compression_complete_) && | |
| 268 !trace_id_ && | |
| 269 feedback_page_data_complete_; | |
| 270 } | |
| 271 | |
| 272 void FeedbackData::SendReport() { | |
| 273 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 274 if (IsDataComplete() && !report_sent_) { | |
| 275 report_sent_ = true; | |
| 276 feedback_util::SendReport(this); | |
| 277 } | |
| 278 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 225183018:
Move feedback files into src/components (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master