Include a timestamp with and add a keyboard shortcut for Feedback.

chrome/browser/ui/webui/feedback_ui.cc

 // Copyright (c) 2012 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/ui/webui/feedback_ui.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
+#include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/feedback/feedback_data.h"
 #include "chrome/browser/feedback/feedback_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
 #include "chrome/browser/ui/webui/screenshot_source.h"
@@ skipping 23 matching lines @@
 #endif
 
 using content::BrowserThread;
 using content::WebContents;
 using content::WebUIMessageHandler;
 
 namespace {
 
 const char kScreenshotBaseUrl[] = "chrome://screenshots/";
 const char kCurrentScreenshotUrl[] = "chrome://screenshots/current";
+
+const char kCategoryTagParameter[] = "categoryTag=";
+const char kDescriptionParameter[] = "description=";
+
 #if defined(OS_CHROMEOS)
 const char kSavedScreenshotsUrl[] = "chrome://screenshots/saved/";
 const char kScreenshotPattern[] = "screenshot-*.png";
 
+const char kTimestampParameter[] = "timestamp=";
+
 const size_t kMaxSavedScreenshots = 2;
 #endif
 
 #if defined(OS_CHROMEOS)
 
 void GetSavedScreenshots(std::vector<std::string>* saved_screenshots,
                          base::WaitableEvent* done) {
   saved_screenshots->clear();
 
   FilePath fileshelf_path;
@@ skipping 50 matching lines @@
 }
 
 }  // namespace
 
 
 namespace browser {
 
 void ShowHtmlFeedbackView(Browser* browser,
                            const std::string& description_template,
                            const std::string& category_tag) {
+#if defined(OS_CHROMEOS)
+  // Grab the timestamp before we do anything else - this is crucial to help
+  // diagnose some hardware issues.
+  base::Time now = base::Time::Now();
+  std::string timestamp = base::DoubleToString(now.ToDoubleT());

[zel, 2012/01/31 16:38:03]

format this to string where you really need the string, pass it as base::Time in
all other places

[rkc, 2012/01/31 18:16:45]

Same reason as given in the other comment.

+#endif
+
   // First check if we're already open (we cannot depend on ShowSingletonTab
   // for this functionality since we need to make *sure* we never get
   // instantiated again while we are open - with singleton tabs, that can
   // happen)
   int feedback_tab_index = GetIndexOfFeedbackTab(browser);
   if (feedback_tab_index >= 0) {
     // Do not refresh screenshot, do not create a new tab
     browser->ActivateTabAt(feedback_tab_index, true);
     return;
   }
 
   std::vector<unsigned char>* last_screenshot_png =
       FeedbackUtil::GetScreenshotPng();
   last_screenshot_png->clear();
 
   gfx::NativeWindow native_window = browser->window()->GetNativeHandle();
   gfx::Rect snapshot_bounds = gfx::Rect(browser->window()->GetBounds().size());
   bool success = browser::GrabWindowSnapshot(native_window,
                                              last_screenshot_png,
                                              snapshot_bounds);
   FeedbackUtil::SetScreenshotSize(success ? snapshot_bounds : gfx::Rect());
 
   std::string feedback_url = std::string(chrome::kChromeUIFeedbackURL) +
-      "#" + base::IntToString(browser->active_index()) +
-      "?description=" + net::EscapeUrlEncodedData(description_template, false) +
-      "&categoryTag=" + net::EscapeUrlEncodedData(category_tag, false);
+      "#" + base::IntToString(browser->active_index()) + "?" +
+      kDescriptionParameter +
+      net::EscapeUrlEncodedData(description_template, false) + "&" +
+      kCategoryTagParameter + net::EscapeUrlEncodedData(category_tag, false);
+
+#if defined(OS_CHROMEOS)
+  feedback_url = feedback_url + "&" + kTimestampParameter +
+                 net::EscapeUrlEncodedData(timestamp, false);
+#endif
   browser->ShowSingletonTab(GURL(feedback_url));
 }
 
 }  // namespace browser
 
 // The handler for Javascript messages related to the "bug report" dialog
 class FeedbackHandler : public WebUIMessageHandler,
                          public base::SupportsWeakPtr<FeedbackHandler> {
  public:
   explicit FeedbackHandler(content::WebContents* tab);
@@ skipping 23 matching lines @@
 
   WebContents* tab_;
   ScreenshotSource* screenshot_source_;
 
   FeedbackData* feedback_data_;
   std::string target_tab_url_;
 #if defined(OS_CHROMEOS)
   // Variables to track SyslogsProvider::RequestSyslogs callback.
   chromeos::system::SyslogsProvider::Handle syslogs_handle_;
   CancelableRequestConsumer syslogs_consumer_;
+
+  // Timestamp of when the feedback request was initiated
+  std::string timestamp_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(FeedbackHandler);
 };
 
 ChromeWebUIDataSource* CreateFeedbackUIHTMLSource(bool successful_init) {
   ChromeWebUIDataSource* source =
       new ChromeWebUIDataSource(chrome::kChromeUIFeedbackHost);
 
   source->AddLocalizedString("title", IDS_FEEDBACK_TITLE);
@@ skipping 85 matching lines @@
   Profile* profile = Profile::FromBrowserContext(tab_->GetBrowserContext());
   profile->GetChromeURLDataManager()->AddDataSource(screenshot_source_);
 }
 
 bool FeedbackHandler::Init() {
   std::string page_url;
   if (tab_->GetController().GetActiveEntry()) {
      page_url = tab_->GetController().GetActiveEntry()->GetURL().spec();
   }
 
-  std::string params = page_url.substr(strlen(chrome::kChromeUIFeedbackURL));
-  // Erase the # - the first character.
-  if (params.length())
-    params.erase(params.begin(), params.begin() + 1);
+  url_parse::Parsed parts;
+  ParseStandardURL(page_url.c_str(), page_url.length(), &parts);
 
-  size_t additional_params_pos = params.find('?');
-  if (additional_params_pos != std::string::npos)
-    params.erase(params.begin() + additional_params_pos, params.end());
+  size_t params_start = page_url.find("?");
+  std::string index_str = page_url.substr(parts.ref.begin,
+                                          params_start - parts.ref.begin);
+  std::string query = page_url.substr(params_start + 1);
 
   int index = 0;
-  if (!base::StringToInt(params, &index))
+  if (!base::StringToInt(index_str, &index))
     return false;
 
+#if defined(OS_CHROMEOS)
+  std::vector<std::string> params;
+  if (Tokenize(query, std::string("&"), &params)) {
+    for (std::vector<std::string>::iterator it = params.begin();
+         it != params.end(); ++it) {
+      if (StartsWithASCII(*it, std::string(kTimestampParameter), true)) {
+        timestamp_ = *it;
+        ReplaceFirstSubstringAfterOffset(&timestamp_,
+                                         0,
+                                         kTimestampParameter,
+                                         "");
+        break;
+      }
+    }
+  }
+#endif
+
   Browser* browser = BrowserList::GetLastActive();
   // Sanity checks.
-  if (((index == 0) && (params != "0")) || !browser ||
+  if (((index == 0) && (index_str != "0")) || !browser ||
       index >= browser->tab_count()) {
     return false;
   }
 
   WebContents* target_tab =
       browser->GetTabContentsWrapperAt(index)->web_contents();
   if (target_tab) {
     target_tab_url_ = target_tab->GetURL().spec();
   }
 
@@ skipping 129 matching lines @@
   feedback_data_->UpdateData(Profile::FromWebUI(web_ui())
                                , target_tab_url_
                                , std::string()
                                , page_url
                                , description
                                , image_ptr
 #if defined(OS_CHROMEOS)
                                , user_email
                                , send_sys_info
                                , false  // sent_report
+                               , timestamp_
 #endif
                                );
 
 #if defined(OS_CHROMEOS)
   // If we don't require sys_info, or we have it, or we never requested it
   // (because libcros failed to load), then send the report now.
   // Otherwise, the report will get sent when we receive sys_info.
   if (!send_sys_info || feedback_data_->sys_info() != NULL ||
       syslogs_handle_ == 0) {
     feedback_data_->SendReport();
@@ skipping 53 matching lines @@
   web_ui->AddMessageHandler(handler);
 
   // The handler's init will determine whether we show the error html page.
   ChromeWebUIDataSource* html_source =
       CreateFeedbackUIHTMLSource(handler->Init());
 
   // Set up the chrome://feedback/ source.
   Profile* profile = Profile::FromWebUI(web_ui);
   profile->GetChromeURLDataManager()->AddDataSource(html_source);
 }