[Downloads] Introduce GUIDs for downloads.

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 "chrome/browser/download/download_history.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
+#include "base/guid.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "components/history/content/browser/download_constants_utils.h"
 #include "components/history/core/browser/download_constants.h"
 #include "components/history/core/browser/download_row.h"
 #include "components/history/core/browser/history_service.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/mock_download_manager.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/api/downloads/downloads_api.h"
 #endif
 
 using testing::DoAll;
 using testing::Invoke;
 using testing::Return;
 using testing::ReturnRefOfCopy;
 using testing::SetArgPointee;
 using testing::WithArg;
 using testing::_;
 
 namespace {
 
-void CheckInfoEqual(const history::DownloadRow& left,
-                    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);
-  EXPECT_EQ(left.by_ext_id, right.by_ext_id);
-  EXPECT_EQ(left.by_ext_name, right.by_ext_name);
-}
-
 typedef DownloadHistory::IdSet IdSet;
 typedef std::vector<history::DownloadRow> InfoVector;
 typedef testing::StrictMock<content::MockDownloadItem> StrictMockDownloadItem;
 
 class FakeHistoryAdapter : public DownloadHistory::HistoryAdapter {
  public:
   FakeHistoryAdapter()
     : DownloadHistory::HistoryAdapter(NULL),
       slow_create_download_(false),
       fail_create_download_(false) {
@@ skipping 62 matching lines @@
 
   void FailCreateDownload() {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     fail_create_download_ = true;
   }
 
   void ExpectDownloadCreated(
       const history::DownloadRow& info) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
-    CheckInfoEqual(info, create_download_info_);
+    EXPECT_EQ(info, create_download_info_);
     create_download_info_ = history::DownloadRow();
   }
 
   void ExpectNoDownloadCreated() {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
-    CheckInfoEqual(history::DownloadRow(), create_download_info_);
+    EXPECT_EQ(history::DownloadRow(), create_download_info_);
   }
 
   void ExpectDownloadUpdated(const history::DownloadRow& info) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
-    CheckInfoEqual(update_download_, info);
+    EXPECT_EQ(update_download_, info);
     update_download_ = history::DownloadRow();
   }
 
   void ExpectNoDownloadUpdated() {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
-    CheckInfoEqual(history::DownloadRow(), update_download_);
+    EXPECT_EQ(history::DownloadRow(), update_download_);
   }
 
   void ExpectNoDownloadsRemoved() {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
     EXPECT_EQ(0, static_cast<int>(remove_downloads_.size()));
   }
 
   void ExpectDownloadsRemoved(const IdSet& ids) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 49 matching lines @@
   void CreateDownloadHistory(scoped_ptr<InfoVector> infos) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     CHECK(infos.get());
     EXPECT_CALL(manager(), AddObserver(_)).WillOnce(WithArg<0>(Invoke(
         this, &DownloadHistoryTest::SetManagerObserver)));
     EXPECT_CALL(manager(), RemoveObserver(_));
     download_created_index_ = 0;
     for (size_t index = 0; index < infos->size(); ++index) {
       const history::DownloadRow& row = infos->at(index);
       content::MockDownloadManager::CreateDownloadItemAdapter adapter(
-          history::ToContentDownloadId(row.id),
-          row.current_path,
-          row.target_path,
-          row.url_chain,
-          row.referrer_url,
-          row.mime_type,
-          row.original_mime_type,
-          row.start_time,
-          row.end_time,
-          row.etag,
-          row.last_modified,
-          row.received_bytes,
-          row.total_bytes,
+          row.guid, history::ToContentDownloadId(row.id), row.current_path,
+          row.target_path, row.url_chain, row.referrer_url, row.mime_type,
+          row.original_mime_type, row.start_time, row.end_time, row.etag,
+          row.last_modified, row.received_bytes, row.total_bytes,
           history::ToContentDownloadState(row.state),
           history::ToContentDownloadDangerType(row.danger_type),
           history::ToContentDownloadInterruptReason(row.interrupt_reason),
           row.opened);
       EXPECT_CALL(manager(), MockCreateDownloadItem(adapter))
         .WillOnce(DoAll(
             InvokeWithoutArgs(
                 this, &DownloadHistoryTest::CallOnDownloadCreatedInOrder),
             Return(&item(index))));
     }
@@ skipping 82 matching lines @@
   }
 
   void InitBasicItem(const base::FilePath::CharType* path,
                      const char* url_string,
                      const char* referrer_string,
                      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_t>(items_.size() + 1), base::FilePath(path),
-             base::FilePath(path), url_chain, referrer,
+    InitItem(base::GenerateGUID(), static_cast<uint32_t>(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_t id,
+  void InitItem(const std::string& guid,
+                uint32_t 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,
@@ skipping 22 matching lines @@
     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 = history::ToHistoryDownloadState(state);
     info->danger_type = history::ToHistoryDownloadDangerType(danger_type);
     info->interrupt_reason =
         history::ToHistoryDownloadInterruptReason(interrupt_reason);
     info->id = history::ToHistoryDownloadId(id);
+    info->guid = guid;
     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), GetGuid()).WillRepeatedly(ReturnRefOfCopy(guid));
     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(mime_type));
@@ skipping 431 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