chrome/browser/feedback/feedback_util.cc

   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_util.h"
   6
   7 #include <sstream>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/bind.h"
  12 #include "base/command_line.h"
  13 #include "base/file_util.h"
  14 #include "base/file_version_info.h"
  15 #include "base/memory/singleton.h"
  16 #include "base/message_loop/message_loop.h"
  17 #include "base/strings/stringprintf.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/win/windows_version.h"
  20 #include "chrome/browser/browser_process.h"
  21 #include "chrome/browser/metrics/variations/variations_http_header_provider.h"
  22 #include "chrome/browser/profiles/profile.h"
  23 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
  24 #include "chrome/browser/ui/browser_list.h"
  25 #include "chrome/common/chrome_switches.h"
  26 #include "chrome/common/chrome_version_info.h"
  27 #include "chrome/common/metrics/metrics_log_manager.h"
  28 #include "content/public/browser/browser_thread.h"
  29 #include "content/public/browser/navigation_controller.h"
  30 #include "content/public/browser/web_contents.h"
  31 #include "content/public/common/content_client.h"
  32 #include "grit/generated_resources.h"
  33 #include "grit/locale_settings.h"
  34 #include "grit/theme_resources.h"
  35 #include "net/base/load_flags.h"
  36 #include "net/http/http_request_headers.h"
  37 #include "net/url_request/url_fetcher.h"
  38 #include "net/url_request/url_fetcher_delegate.h"
  39 #include "net/url_request/url_request_status.h"
  40 #include "third_party/icu/source/common/unicode/locid.h"
  41 #include "third_party/zlib/google/zip.h"
  42 #include "ui/base/l10n/l10n_util.h"
  43 #include "url/gurl.h"
  44
  45 using content::WebContents;
  46
  47 namespace {
  48 const base::FilePath::CharType kLogsFilename[] =
  49     FILE_PATH_LITERAL("system_logs.txt");
  50 }
  51
  52 namespace chrome {
  53 const char kAppLauncherCategoryTag[] = "AppLauncher";
  54 }  // namespace chrome
  55
  56 const int kFeedbackVersion = 1;
  57
  58 const char kReportPhishingUrl[] =
  59     "http://www.google.com/safebrowsing/report_phish/";
  60
  61 // URL to post bug reports to.
  62 const char kFeedbackPostUrl[] =
  63     "https://www.google.com/tools/feedback/chrome/__submit";
  64
  65 const char kProtBufMimeType[] = "application/x-protobuf";
  66 const char kPngMimeType[] = "image/png";
  67
  68 // Tags we use in product specific data
  69 const char kChromeVersionTag[] = "CHROME VERSION";
  70 const char kOsVersionTag[] = "OS VERSION";
  71
  72 const int kHttpPostSuccessNoContent = 204;
  73 const int kHttpPostFailNoConnection = -1;
  74 const int kHttpPostFailClientError = 400;
  75 const int kHttpPostFailServerError = 500;
  76
  77 const int64 kInitialRetryDelay = 900000;  // 15 minutes
  78 const int64 kRetryDelayIncreaseFactor = 2;
  79 const int64 kRetryDelayLimit = 14400000;  // 4 hours
  80
  81 #if defined(OS_CHROMEOS)
  82 const size_t kFeedbackMaxLength = 4 * 1024;
  83 const size_t kFeedbackMaxLineCount = 40;
  84
  85 const char kArbitraryMimeType[] = "application/octet-stream";
  86 const char kLogsAttachmentName[] = "system_logs.zip";
  87
  88 const char kTimestampTag[] = "TIMESTAMP";
  89
  90 const int kChromeOSProductId = 208;
  91 #endif
  92
  93 const int kChromeBrowserProductId = 237;
  94
  95 // Simple net::URLFetcherDelegate to clean up URLFetcher on completion.
  96 class FeedbackUtil::PostCleanup : public net::URLFetcherDelegate {
  97  public:
  98   PostCleanup(Profile* profile,
  99               std::string* post_body,
 100               int64 previous_delay) : profile_(profile),
 101                                       post_body_(post_body),
 102                                       previous_delay_(previous_delay) { }
 103   // Overridden from net::URLFetcherDelegate.
 104   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 105
 106  protected:
 107   virtual ~PostCleanup() {}
 108
 109  private:
 110   Profile* profile_;
 111   std::string* post_body_;
 112   int64 previous_delay_;
 113
 114   DISALLOW_COPY_AND_ASSIGN(PostCleanup);
 115 };
 116
 117 // Don't use the data parameter, instead use the pointer we pass into every
 118 // post cleanup object - that pointer will be deleted and deleted only on a
 119 // successful post to the feedback server.
 120 void FeedbackUtil::PostCleanup::OnURLFetchComplete(
 121     const net::URLFetcher* source) {
 122   std::stringstream error_stream;
 123   int response_code = source->GetResponseCode();
 124   if (response_code == kHttpPostSuccessNoContent) {
 125     // We've sent our report, delete the report data
 126     delete post_body_;
 127
 128     error_stream << "Success";
 129   } else {
 130     // Uh oh, feedback failed, send it off to retry
 131     if (previous_delay_) {
 132       if (previous_delay_ < kRetryDelayLimit)
 133         previous_delay_ *= kRetryDelayIncreaseFactor;
 134     } else {
 135       previous_delay_ = kInitialRetryDelay;
 136     }
 137     FeedbackUtil::DispatchFeedback(profile_, post_body_, previous_delay_);
 138
 139     // Process the error for debug output
 140     if (response_code == kHttpPostFailNoConnection) {
 141       error_stream << "No connection to server.";
 142     } else if ((response_code > kHttpPostFailClientError) &&
 143         (response_code < kHttpPostFailServerError)) {
 144       error_stream << "Client error: HTTP response code " << response_code;
 145     } else if (response_code > kHttpPostFailServerError) {
 146       error_stream << "Server error: HTTP response code " << response_code;
 147     } else {
 148       error_stream << "Unknown error: HTTP response code " << response_code;
 149     }
 150   }
 151
 152   LOG(WARNING) << "FEEDBACK: Submission to feedback server (" <<
 153                source->GetURL() << ") status: " << error_stream.str();
 154
 155   // Delete the URLFetcher.
 156   delete source;
 157   // And then delete ourselves.
 158   delete this;
 159 }
 160
 161 // static
 162 void FeedbackUtil::SetOSVersion(std::string* os_version) {
 163 #if defined(OS_WIN)
 164   base::win::OSInfo* os_info = base::win::OSInfo::GetInstance();
 165   base::win::OSInfo::VersionNumber version_number = os_info->version_number();
 166   *os_version = base::StringPrintf("%d.%d.%d",
 167                                    version_number.major,
 168                                    version_number.minor,
 169                                    version_number.build);
 170   int service_pack = os_info->service_pack().major;
 171   if (service_pack > 0)
 172     os_version->append(base::StringPrintf("Service Pack %d", service_pack));
 173 #elif defined(OS_MACOSX)
 174   *os_version = base::SysInfo::OperatingSystemVersion();
 175 #else
 176   *os_version = "unknown";
 177 #endif
 178 }
 179
 180 // static
 181 void FeedbackUtil::DispatchFeedback(Profile* profile,
 182                                     std::string* post_body,
 183                                     int64 delay) {
 184   DCHECK(post_body);
 185
 186   base::MessageLoop::current()->PostDelayedTask(
 187       FROM_HERE,
 188       base::Bind(&FeedbackUtil::SendFeedback, profile, post_body, delay),
 189       base::TimeDelta::FromMilliseconds(delay));
 190 }
 191
 192 // static
 193 void FeedbackUtil::SendFeedback(Profile* profile,
 194                                 std::string* post_body,
 195                                 int64 previous_delay) {
 196   DCHECK(post_body);
 197
 198   GURL post_url;
 199   if (CommandLine::ForCurrentProcess()->
 200       HasSwitch(switches::kFeedbackServer))
 201     post_url = GURL(CommandLine::ForCurrentProcess()->
 202         GetSwitchValueASCII(switches::kFeedbackServer));
 203   else
 204     post_url = GURL(kFeedbackPostUrl);
 205
 206   net::URLFetcher* fetcher = net::URLFetcher::Create(
 207       post_url, net::URLFetcher::POST,
 208       new FeedbackUtil::PostCleanup(profile, post_body, previous_delay));
 209   fetcher->SetRequestContext(profile->GetRequestContext());
 210   fetcher->SetLoadFlags(
 211       net::LOAD_DO_NOT_SAVE_COOKIES | net::LOAD_DO_NOT_SEND_COOKIES);
 212
 213   net::HttpRequestHeaders headers;
 214   chrome_variations::VariationsHttpHeaderProvider::GetInstance()->AppendHeaders(
 215       fetcher->GetOriginalURL(), profile->IsOffTheRecord(), false, &headers);
 216   fetcher->SetExtraRequestHeaders(headers.ToString());
 217
 218   fetcher->SetUploadData(std::string(kProtBufMimeType), *post_body);
 219   fetcher->Start();
 220 }
 221
 222
 223 // static
 224 void FeedbackUtil::AddFeedbackData(
 225     userfeedback::ExtensionSubmit* feedback_data,
 226     const std::string& key, const std::string& value) {
 227   // Don't bother with empty keys or values
 228   if (key == "" || value == "") return;
 229   // Create log_value object and add it to the web_data object
 230   userfeedback::ProductSpecificData log_value;
 231   log_value.set_key(key);
 232   log_value.set_value(value);
 233   userfeedback::WebData* web_data = feedback_data->mutable_web_data();
 234   *(web_data->add_product_specific_data()) = log_value;
 235 }
 236
 237 #if defined(OS_CHROMEOS)
 238 bool FeedbackUtil::ValidFeedbackSize(const std::string& content) {
 239   if (content.length() > kFeedbackMaxLength)
 240     return false;
 241   const size_t line_count = std::count(content.begin(), content.end(), '\n');
 242   if (line_count > kFeedbackMaxLineCount)
 243     return false;
 244   return true;
 245 }
 246 #endif
 247
 248 // static
 249 void FeedbackUtil::SendReport(scoped_refptr<FeedbackData> data) {
 250   if (!data.get()) {
 251     LOG(ERROR) << "FeedbackUtil::SendReport called with NULL data!";
 252     NOTREACHED();
 253     return;
 254   }
 255
 256   // Create google feedback protocol buffer objects
 257   userfeedback::ExtensionSubmit feedback_data;
 258   // type id set to 0, unused field but needs to be initialized to 0
 259   feedback_data.set_type_id(0);
 260
 261   userfeedback::CommonData* common_data = feedback_data.mutable_common_data();
 262   userfeedback::WebData* web_data = feedback_data.mutable_web_data();
 263
 264   // Set our user agent.
 265   userfeedback::Navigator* navigator = web_data->mutable_navigator();
 266   navigator->set_user_agent(content::GetUserAgent(GURL()));
 267
 268   // Set GAIA id to 0. We're not using gaia id's for recording
 269   // use feedback - we're using the e-mail field, allows users to
 270   // submit feedback from incognito mode and specify any mail id
 271   // they wish
 272   common_data->set_gaia_id(0);
 273
 274   // Add the user e-mail to the feedback object
 275   common_data->set_user_email(data->user_email());
 276
 277   // Add the description to the feedback object
 278   common_data->set_description(data->description());
 279
 280   // Add the language
 281   std::string chrome_locale = g_browser_process->GetApplicationLocale();
 282   common_data->set_source_description_language(chrome_locale);
 283
 284   // Set the url
 285   web_data->set_url(data->page_url());
 286
 287   // Add the Chrome version
 288   chrome::VersionInfo version_info;
 289   if (version_info.is_valid()) {
 290     std::string chrome_version = version_info.Name() + " - " +
 291         version_info.Version() +
 292         " (" + version_info.LastChange() + ")";
 293     AddFeedbackData(&feedback_data, std::string(kChromeVersionTag),
 294                     chrome_version);
 295   }
 296
 297   // We don't need the OS version for ChromeOS since we get it in
 298   // CHROMEOS_RELEASE_VERSION from /etc/lsb-release
 299 #if !defined(OS_CHROMEOS)
 300   // Add OS version (eg, for WinXP SP2: "5.1.2600 Service Pack 2").
 301   std::string os_version;
 302   SetOSVersion(&os_version);
 303   AddFeedbackData(&feedback_data, std::string(kOsVersionTag), os_version);
 304 #endif
 305
 306   // Include the page image if we have one.
 307   if (data->image().get() && data->image()->size()) {
 308     userfeedback::PostedScreenshot screenshot;
 309     screenshot.set_mime_type(kPngMimeType);
 310     // Set the dimensions of the screenshot
 311     userfeedback::Dimensions dimensions;
 312     gfx::Rect& screen_size = GetScreenshotSize();
 313     dimensions.set_width(static_cast<float>(screen_size.width()));
 314     dimensions.set_height(static_cast<float>(screen_size.height()));
 315     *(screenshot.mutable_dimensions()) = dimensions;
 316
 317     int image_data_size = data->image()->size();
 318     char* image_data = reinterpret_cast<char*>(&(data->image()->front()));
 319     screenshot.set_binary_content(std::string(image_data, image_data_size));
 320
 321     // Set the screenshot object in feedback
 322     *(feedback_data.mutable_screenshot()) = screenshot;
 323   }
 324
 325 #if defined(OS_CHROMEOS)
 326   if (data->sys_info()) {
 327     // Add the product specific data
 328     for (chromeos::SystemLogsResponse::const_iterator i =
 329         data->sys_info()->begin(); i != data->sys_info()->end(); ++i) {
 330       if (ValidFeedbackSize(i->second)) {
 331         AddFeedbackData(&feedback_data, i->first, i->second);
 332       }
 333     }
 334
 335     if (data->compressed_logs() && data->compressed_logs()->size()) {
 336       userfeedback::ProductSpecificBinaryData attachment;
 337       attachment.set_mime_type(kArbitraryMimeType);
 338       attachment.set_name(kLogsAttachmentName);
 339       attachment.set_data(*(data->compressed_logs()));
 340       *(feedback_data.add_product_specific_binary_data()) = attachment;
 341     }
 342   }
 343
 344   if (data->timestamp() != "")
 345     AddFeedbackData(&feedback_data, std::string(kTimestampTag),
 346                     data->timestamp());
 347
 348   if (data->attached_filename() != "" &&
 349       data->attached_filedata() &&
 350       data->attached_filedata()->size()) {
 351     userfeedback::ProductSpecificBinaryData attached_file;
 352     attached_file.set_mime_type(kArbitraryMimeType);
 353     attached_file.set_name(data->attached_filename());
 354     attached_file.set_data(*data->attached_filedata());
 355     *(feedback_data.add_product_specific_binary_data()) = attached_file;
 356   }
 357 #endif
 358
 359   // Set our category tag if we have one
 360   if (data->category_tag().size())
 361     feedback_data.set_bucket(data->category_tag());
 362
 363   // Set our Chrome specific data
 364   userfeedback::ChromeData chrome_data;
 365   chrome_data.set_chrome_platform(
 366 #if defined(OS_CHROMEOS)
 367       userfeedback::ChromeData_ChromePlatform_CHROME_OS);
 368   userfeedback::ChromeOsData chrome_os_data;
 369   chrome_os_data.set_category(
 370       userfeedback::ChromeOsData_ChromeOsCategory_OTHER);
 371   *(chrome_data.mutable_chrome_os_data()) = chrome_os_data;
 372   feedback_data.set_product_id(kChromeOSProductId);
 373 #else
 374       userfeedback::ChromeData_ChromePlatform_CHROME_BROWSER);
 375   userfeedback::ChromeBrowserData chrome_browser_data;
 376   chrome_browser_data.set_category(
 377       userfeedback::ChromeBrowserData_ChromeBrowserCategory_OTHER);
 378   *(chrome_data.mutable_chrome_browser_data()) = chrome_browser_data;
 379   feedback_data.set_product_id(kChromeBrowserProductId);
 380 #endif
 381
 382   *(feedback_data.mutable_chrome_data()) = chrome_data;
 383
 384   // Serialize our report to a string pointer we can pass around
 385   std::string* post_body = new std::string;
 386   feedback_data.SerializeToString(post_body);
 387
 388   // We have the body of our POST, so send it off to the server with 0 delay
 389   DispatchFeedback(data->profile(), post_body, 0);
 390 }
 391
 392 #if defined(FULL_SAFE_BROWSING)
 393 // static
 394 void FeedbackUtil::ReportPhishing(WebContents* current_tab,
 395                                   const std::string& phishing_url) {
 396   current_tab->GetController().LoadURL(
 397       safe_browsing_util::GeneratePhishingReportUrl(
 398           kReportPhishingUrl, phishing_url,
 399           false /* not client-side detection */),
 400       content::Referrer(),
 401       content::PAGE_TRANSITION_LINK,
 402       std::string());
 403 }
 404 #endif
 405
 406 static std::vector<unsigned char>* screenshot_png = NULL;
 407 static gfx::Rect* screenshot_size = NULL;
 408
 409 // static
 410 std::vector<unsigned char>* FeedbackUtil::GetScreenshotPng() {
 411   if (screenshot_png == NULL)
 412     screenshot_png = new std::vector<unsigned char>;
 413   return screenshot_png;
 414 }
 415
 416 // static
 417 void FeedbackUtil::ClearScreenshotPng() {
 418   if (screenshot_png)
 419     screenshot_png->clear();
 420 }
 421
 422 // static
 423 gfx::Rect& FeedbackUtil::GetScreenshotSize() {
 424   if (screenshot_size == NULL)
 425     screenshot_size = new gfx::Rect();
 426   return *screenshot_size;
 427 }
 428
 429 // static
 430 void FeedbackUtil::SetScreenshotSize(const gfx::Rect& rect) {
 431   gfx::Rect& screen_size = GetScreenshotSize();
 432   screen_size = rect;
 433 }
 434
 435 // static
 436 bool FeedbackUtil::ZipString(const std::string& logs,
 437                              std::string* compressed_logs) {
 438   base::FilePath temp_path;
 439   base::FilePath zip_file;
 440
 441   // Create a temporary directory, put the logs into a file in it. Create
 442   // another temporary file to receive the zip file in.
 443   if (!file_util::CreateNewTempDirectory(FILE_PATH_LITERAL(""), &temp_path))
 444     return false;
 445   if (file_util::WriteFile(temp_path.Append(kLogsFilename),
 446                            logs.c_str(), logs.size()) == -1)
 447     return false;
 448   if (!file_util::CreateTemporaryFile(&zip_file))
 449     return false;
 450
 451   if (!zip::Zip(temp_path, zip_file, false))
 452     return false;
 453
 454   if (!file_util::ReadFileToString(zip_file, compressed_logs))
 455     return false;
 456
 457   return true;
 458 }