Add mime type information to the download database

chrome/browser/download/download_history_unittest.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 <set>
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/history/download_database.h"
 #include "chrome/browser/history/download_row.h"
 #include "chrome/browser/history/history_service.h"
 #include "content/public/test/mock_download_item.h"
@@ skipping 20 matching lines @@
                     const history::DownloadRow& right) {
   EXPECT_EQ(left.current_path.value(), right.current_path.value());
   EXPECT_EQ(left.target_path.value(), right.target_path.value());
   EXPECT_EQ(left.url_chain.size(), right.url_chain.size());
   for (unsigned int i = 0;
        i < left.url_chain.size() && i < right.url_chain.size();
        ++i) {
     EXPECT_EQ(left.url_chain[i].spec(), right.url_chain[i].spec());
   }
   EXPECT_EQ(left.referrer_url.spec(), right.referrer_url.spec());
+  EXPECT_EQ(left.mime_type, right.mime_type);
+  EXPECT_EQ(left.original_mime_type, right.original_mime_type);
   EXPECT_EQ(left.start_time.ToTimeT(), right.start_time.ToTimeT());
   EXPECT_EQ(left.end_time.ToTimeT(), right.end_time.ToTimeT());
   EXPECT_EQ(left.etag, right.etag);
   EXPECT_EQ(left.last_modified, right.last_modified);
   EXPECT_EQ(left.received_bytes, right.received_bytes);
   EXPECT_EQ(left.total_bytes, right.total_bytes);
   EXPECT_EQ(left.state, right.state);
   EXPECT_EQ(left.danger_type, right.danger_type);
   EXPECT_EQ(left.id, right.id);
   EXPECT_EQ(left.opened, right.opened);
@@ skipping 175 matching lines @@
         this, &DownloadHistoryTest::SetManagerObserver)));
     EXPECT_CALL(manager(), RemoveObserver(_));
     download_created_index_ = 0;
     for (size_t index = 0; index < infos->size(); ++index) {
       content::MockDownloadManager::CreateDownloadItemAdapter adapter(
           infos->at(index).id,
           infos->at(index).current_path,
           infos->at(index).target_path,
           infos->at(index).url_chain,
           infos->at(index).referrer_url,
+          infos->at(index).mime_type,
+          infos->at(index).original_mime_type,
           infos->at(index).start_time,
           infos->at(index).end_time,
           infos->at(index).etag,
           infos->at(index).last_modified,
           infos->at(index).received_bytes,
           infos->at(index).total_bytes,
           infos->at(index).state,
           infos->at(index).danger_type,
           infos->at(index).interrupt_reason,
           infos->at(index).opened);
@@ skipping 93 matching lines @@
                      history::DownloadRow* info) {
     GURL url(url_string);
     GURL referrer(referrer_string);
     std::vector<GURL> url_chain;
     url_chain.push_back(url);
     InitItem(static_cast<uint32>(items_.size() + 1),
              base::FilePath(path),
              base::FilePath(path),
              url_chain,
              referrer,
+             "application/octet-stream",
+             "application/octet-stream",
              (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
              (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
              "Etag",
              "abc",
              100,
              100,
              content::DownloadItem::COMPLETE,
              content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
              content::DOWNLOAD_INTERRUPT_REASON_NONE,
              false,
              std::string(),
              std::string(),
              info);
   }
 
   void InitItem(
       uint32 id,
       const base::FilePath& current_path,
       const base::FilePath& target_path,
       const std::vector<GURL>& url_chain,
       const GURL& referrer,
+      const std::string& mime_type,
+      const std::string& original_mime_type,
       const base::Time& start_time,
       const base::Time& end_time,
       const std::string& etag,
       const std::string& last_modified,
       int64 received_bytes,
       int64 total_bytes,
       content::DownloadItem::DownloadState state,
       content::DownloadDangerType danger_type,
       content::DownloadInterruptReason interrupt_reason,
       bool opened,
       const std::string& by_extension_id,
       const std::string& by_extension_name,
       history::DownloadRow* info) {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
     size_t index = items_.size();
     StrictMockDownloadItem* mock_item = new StrictMockDownloadItem();
     items_.push_back(mock_item);
 
     info->current_path = current_path;
     info->target_path = target_path;
     info->url_chain = url_chain;
     info->referrer_url = referrer;
+    info->mime_type = mime_type;
+    info->original_mime_type = original_mime_type;
     info->start_time = start_time;
     info->end_time = end_time;
     info->etag = etag;
     info->last_modified = last_modified;
     info->received_bytes = received_bytes;
     info->total_bytes = total_bytes;
     info->state = state;
     info->danger_type = danger_type;
     info->interrupt_reason = interrupt_reason;
     info->id = id;
     info->opened = opened;
     info->by_ext_id = by_extension_id;
     info->by_ext_name = by_extension_name;
 
     EXPECT_CALL(item(index), GetId()).WillRepeatedly(Return(id));
     EXPECT_CALL(item(index), GetFullPath())
         .WillRepeatedly(ReturnRefOfCopy(current_path));
     EXPECT_CALL(item(index), GetTargetFilePath())
         .WillRepeatedly(ReturnRefOfCopy(target_path));
     DCHECK_LE(1u, url_chain.size());
     EXPECT_CALL(item(index), GetURL())
         .WillRepeatedly(ReturnRefOfCopy(url_chain[0]));
     EXPECT_CALL(item(index), GetUrlChain())
         .WillRepeatedly(ReturnRefOfCopy(url_chain));
-    EXPECT_CALL(item(index), GetMimeType())
-        .WillRepeatedly(Return("application/octet-stream"));
+    EXPECT_CALL(item(index), GetMimeType()).WillRepeatedly(Return(mime_type));
+    EXPECT_CALL(item(index), GetOriginalMimeType()).WillRepeatedly(Return(
+        original_mime_type));
     EXPECT_CALL(item(index), GetReferrerUrl())
         .WillRepeatedly(ReturnRefOfCopy(referrer));
     EXPECT_CALL(item(index), GetStartTime()).WillRepeatedly(Return(start_time));
     EXPECT_CALL(item(index), GetEndTime()).WillRepeatedly(Return(end_time));
     EXPECT_CALL(item(index), GetETag()).WillRepeatedly(ReturnRefOfCopy(etag));
     EXPECT_CALL(item(index), GetLastModifiedTime())
         .WillRepeatedly(ReturnRefOfCopy(last_modified));
     EXPECT_CALL(item(index), GetReceivedBytes())
         .WillRepeatedly(Return(received_bytes));
     EXPECT_CALL(item(index), GetTotalBytes())
@@ skipping 418 matching lines @@
   FinishCreateDownload();
   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 
   // ItemAdded should call OnDownloadUpdated, which should detect that the item
   // changed while it was being added and call UpdateDownload immediately.
   info.opened = true;
   ExpectDownloadUpdated(info);
 }
 
 }  // anonymous namespace