Remove screen dimensions from image sent with Feedback.

chrome/browser/feedback/feedback_util.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/feedback/feedback_util.h"
 
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/feedback_private/feedback_private_api.h"
 #include "chrome/browser/feedback/feedback_data.h"
 #include "chrome/browser/metrics/variations/variations_http_header_provider.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/metrics/metrics_log_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
@@ skipping 18 matching lines @@
 #include "ui/aura/window.h"
 #endif
 
 namespace {
 
 const base::FilePath::CharType kLogsFilename[] =
     FILE_PATH_LITERAL("system_logs.txt");
 
 void DispatchFeedback(Profile* profile, std::string* post_body, int64 delay);
 
-// Check the key/value pair to see if it is one of the screensize, keys. If so,
-// populate the screensize structure with the key.
-bool IsScreensizeInfo(const std::string key,
-                      const std::string value,
-                      gfx::Rect* screen_size) {
-  if (key == FeedbackData::kScreensizeHeightKey) {
-    int height = 0;
-    base::StringToInt(value, &height);
-    screen_size->SetRect(0, 0, screen_size->width(), height);
-    return true;
-  } else if (key == FeedbackData::kScreensizeWidthKey) {
-    int width = 0;
-    base::StringToInt(value, &width);
-    screen_size->SetRect(0, 0, width, screen_size->height());
-    return true;
-  }
-  return false;
-}
-
 GURL GetTargetTabUrl(int session_id, int index) {
   Browser* browser = chrome::FindBrowserWithID(session_id);
   // Sanity checks.
   if (!browser || index >= browser->tab_strip_model()->count())
     return GURL();
 
   if (index >= 0) {
     content::WebContents* target_tab =
         browser->tab_strip_model()->GetWebContentsAt(index);
     if (target_tab)
       return target_tab->GetURL();
   }
 
   return GURL();
 }
 
-gfx::Rect GetScreenSize(Browser* browser) {
-#if defined(OS_CHROMEOS)
-  // For ChromeOS, don't use the browser window but the root window
-  // instead to grab the screenshot. We want everything on the screen, not
-  // just the current browser.
-  gfx::NativeWindow native_window = ash::Shell::GetPrimaryRootWindow();
-  return gfx::Rect(native_window->bounds());
-#else
-  return gfx::Rect(browser->window()->GetBounds().size());
-#endif
-}
-
 // URL to post bug reports to.
 const char kFeedbackPostUrl[] =
     "https://www.google.com/tools/feedback/chrome/__submit";
 
 const char kProtBufMimeType[] = "application/x-protobuf";
 const char kPngMimeType[] = "image/png";
 
 const int kHttpPostSuccessNoContent = 204;
 const int kHttpPostFailNoConnection = -1;
 const int kHttpPostFailClientError = 400;
@@ skipping 126 matching lines @@
   *(web_data->add_product_specific_data()) = log_value;
 }
 
 }  // namespace
 
 namespace chrome {
 
 const char kAppLauncherCategoryTag[] = "AppLauncher";
 
 void ShowFeedbackPage(Browser* browser,
-                    const std::string& description_template,
-                    const std::string& category_tag) {
-  DCHECK(browser);
+                      const std::string& description_template,
+                      const std::string& category_tag) {
+  GURL page_url;
+  if (browser) {
+    page_url = GetTargetTabUrl(browser->session_id().id(),
+                               browser->tab_strip_model()->active_index());
+  }
 
-  // Get the current browser's screensize and send it with the feedback request
-  // event - this browser may have changed or even been closed by the time that
-  // feedback is sent.
-  gfx::Rect screen_size = GetScreenSize(browser);
-  GURL page_url = GetTargetTabUrl(
-      browser->session_id().id(), browser->tab_strip_model()->active_index());
+  Profile* profile = NULL;
+  if (browser) {
+    profile = browser->profile();
+  } else {
+    profile = ProfileManager::GetLastUsedProfileAllowedByPolicy();
+  }
+  if (!profile) {
+    LOG(ERROR) << "Cannot invoke feedback: No profile found!";
+    return;
+  }
 
   extensions::FeedbackPrivateAPI* api =
       extensions::FeedbackPrivateAPI::GetFactoryInstance()->GetForProfile(
-          browser->profile());
+          profile);
 
   api->RequestFeedback(description_template,
                        category_tag,
-                       page_url,
-                       screen_size);
+                       page_url);
 }
 
 }  // namespace chrome
 
 namespace feedback_util {
 
 void SendReport(scoped_refptr<FeedbackData> data) {
   if (!data.get()) {
     LOG(ERROR) << "SendReport called with NULL data!";
     NOTREACHED();
@@ skipping 14 matching lines @@
   common_data->set_source_description_language(chrome_locale);
 
   userfeedback::WebData* web_data = feedback_data.mutable_web_data();
   web_data->set_url(data->page_url());
   web_data->mutable_navigator()->set_user_agent(content::GetUserAgent(GURL()));
 
   gfx::Rect screen_size;
   if (data->sys_info()) {
     for (FeedbackData::SystemLogsMap::const_iterator i =
         data->sys_info()->begin(); i != data->sys_info()->end(); ++i) {
-      if (!IsScreensizeInfo(i->first, i->second, &screen_size)) {
-        if (FeedbackData::BelowCompressionThreshold(i->second))
-          AddFeedbackData(&feedback_data, i->first, i->second);
-      }
+      if (FeedbackData::BelowCompressionThreshold(i->second))
+        AddFeedbackData(&feedback_data, i->first, i->second);
     }
 
     if (data->compressed_logs() && data->compressed_logs()->size()) {
       userfeedback::ProductSpecificBinaryData attachment;
       attachment.set_mime_type(kArbitraryMimeType);
       attachment.set_name(kLogsAttachmentName);
       attachment.set_data(*(data->compressed_logs()));
       *(feedback_data.add_product_specific_binary_data()) = attachment;
     }
   }
@@ skipping 11 matching lines @@
     attached_file.set_data(*data->attached_filedata());
     *(feedback_data.add_product_specific_binary_data()) = attached_file;
   }
 
   // NOTE: Screenshot needs to be processed after system info since we'll get
   // the screenshot dimensions from system info.
   if (data->image() && data->image()->size()) {
     userfeedback::PostedScreenshot screenshot;
     screenshot.set_mime_type(kPngMimeType);
 
-    // Set the dimensions of the screenshot
+    // Set that we 'have' dimensions of the screenshot. These dimensions are
+    // ignored by the server but are a 'required' field in the protobuf.
     userfeedback::Dimensions dimensions;
-    dimensions.set_width(static_cast<float>(screen_size.width()));
-    dimensions.set_height(static_cast<float>(screen_size.height()));
+    dimensions.set_width(0.0);
+    dimensions.set_height(0.0);
 
     *(screenshot.mutable_dimensions()) = dimensions;
     screenshot.set_binary_content(*data->image());
 
     *(feedback_data.mutable_screenshot()) = screenshot;
   }
 
   if (data->category_tag().size())
     feedback_data.set_bucket(data->category_tag());
 
@@ skipping 44 matching lines @@
   if (!zip::Zip(temp_path, zip_file, false))
     return false;
 
   if (!base::ReadFileToString(zip_file, compressed_logs))
     return false;
 
   return true;
 }
 
 }  // namespace feedback_util