downloads.query: parse numerical query properties as double, not int.

chrome/browser/download/download_query.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/download/download_query.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 23 matching lines @@
 using content::DownloadDangerType;
 using content::DownloadItem;
 
 namespace {
 
 // Templatized base::Value::GetAs*().
 template <typename T> bool GetAs(const base::Value& in, T* out);
 template<> bool GetAs(const base::Value& in, bool* out) {
   return in.GetAsBoolean(out);
 }
-template<> bool GetAs(const base::Value& in, int* out) {
-  return in.GetAsInteger(out);
+template <>
+bool GetAs(const base::Value& in, double* out) {
+  return in.GetAsDouble(out);
 }
 template<> bool GetAs(const base::Value& in, std::string* out) {
   return in.GetAsString(out);
 }
 template<> bool GetAs(const base::Value& in, base::string16* out) {
   return in.GetAsString(out);
 }
 template<> bool GetAs(const base::Value& in, std::vector<base::string16>* out) {
   out->clear();
   const base::ListValue* list = NULL;
@@ skipping 62 matching lines @@
 }
 
 static DownloadItem::DownloadState GetState(const DownloadItem& item) {
   return item.GetState();
 }
 
 static DownloadDangerType GetDangerType(const DownloadItem& item) {
   return item.GetDangerType();
 }
 
-static int GetReceivedBytes(const DownloadItem& item) {
+static double GetReceivedBytes(const DownloadItem& item) {
   return item.GetReceivedBytes();
 }
 
-static int GetTotalBytes(const DownloadItem& item) {
+static double GetTotalBytes(const DownloadItem& item) {
   return item.GetTotalBytes();
 }
 
 static std::string GetMimeType(const DownloadItem& item) {
   return item.GetMimeType();
 }
 
 static bool IsPaused(const DownloadItem& item) {
   return item.IsPaused();
 }
@@ skipping 113 matching lines @@
 
 void DownloadQuery::AddFilter(DownloadDangerType danger) {
   AddFilter(base::Bind(&FieldMatches<DownloadDangerType>, danger, EQ,
       base::Bind(&GetDangerType)));
 }
 
 bool DownloadQuery::AddFilter(DownloadQuery::FilterType type,
                               const base::Value& value) {
   switch (type) {
     case FILTER_BYTES_RECEIVED:
-      return AddFilter(BuildFilter<int>(value, EQ, &GetReceivedBytes));
+      return AddFilter(BuildFilter<double>(value, EQ, &GetReceivedBytes));
     case FILTER_DANGER_ACCEPTED:
       return AddFilter(BuildFilter<bool>(value, EQ, &GetDangerAccepted));
     case FILTER_EXISTS:
       return AddFilter(BuildFilter<bool>(value, EQ, &GetExists));
     case FILTER_FILENAME:
       return AddFilter(BuildFilter<base::string16>(value, EQ, &GetFilename));
     case FILTER_FILENAME_REGEX:
       return AddFilter(BuildRegexFilter(value, &GetFilenameUTF8));
     case FILTER_MIME:
       return AddFilter(BuildFilter<std::string>(value, EQ, &GetMimeType));
@@ skipping 11 matching lines @@
       return AddFilter(BuildFilter<std::string>(value, LT, &GetEndTime));
     case FILTER_END_TIME:
       return AddFilter(BuildFilter<std::string>(value, EQ, &GetEndTime));
     case FILTER_STARTED_AFTER:
       return AddFilter(BuildFilter<std::string>(value, GT, &GetStartTime));
     case FILTER_STARTED_BEFORE:
       return AddFilter(BuildFilter<std::string>(value, LT, &GetStartTime));
     case FILTER_START_TIME:
       return AddFilter(BuildFilter<std::string>(value, EQ, &GetStartTime));
     case FILTER_TOTAL_BYTES:
-      return AddFilter(BuildFilter<int>(value, EQ, &GetTotalBytes));
+      return AddFilter(BuildFilter<double>(value, EQ, &GetTotalBytes));
     case FILTER_TOTAL_BYTES_GREATER:
-      return AddFilter(BuildFilter<int>(value, GT, &GetTotalBytes));
+      return AddFilter(BuildFilter<double>(value, GT, &GetTotalBytes));
     case FILTER_TOTAL_BYTES_LESS:
-      return AddFilter(BuildFilter<int>(value, LT, &GetTotalBytes));
+      return AddFilter(BuildFilter<double>(value, LT, &GetTotalBytes));
     case FILTER_URL:
       return AddFilter(BuildFilter<std::string>(value, EQ, &GetUrl));
     case FILTER_URL_REGEX:
       return AddFilter(BuildRegexFilter(value, &GetUrl));
   }
   return false;
 }
 
 bool DownloadQuery::Matches(const DownloadItem& item) const {
   for (FilterCallbackVector::const_iterator filter = filters_.begin();
@@ skipping 98 matching lines @@
       sorters_.push_back(Sorter::Build<DownloadItem::DownloadState>(
           direction, &GetState));
       break;
     case SORT_PAUSED:
       sorters_.push_back(Sorter::Build<bool>(direction, &IsPaused));
       break;
     case SORT_MIME:
       sorters_.push_back(Sorter::Build<std::string>(direction, &GetMimeType));
       break;
     case SORT_BYTES_RECEIVED:
-      sorters_.push_back(Sorter::Build<int>(direction, &GetReceivedBytes));
+      sorters_.push_back(Sorter::Build<double>(direction, &GetReceivedBytes));
       break;
     case SORT_TOTAL_BYTES:
-      sorters_.push_back(Sorter::Build<int>(direction, &GetTotalBytes));
+      sorters_.push_back(Sorter::Build<double>(direction, &GetTotalBytes));
       break;
   }
 }
 
 void DownloadQuery::FinishSearch(DownloadQuery::DownloadVector* results) const {
  if (!sorters_.empty()) {
     std::partial_sort(results->begin(),
                       results->begin() + std::min(limit_, results->size()),
                       results->end(),
                       DownloadComparator(sorters_));
   }
 
   if (results->size() > limit_)
     results->resize(limit_);
 }