BASELINE: Update Chromium to 66.0.3359.156

Change-Id: I0c9831ad39911a086b6377b16f995ad75a51e441
Reviewed-by: Michal Klocek <michal.klocek@qt.io>

1 files changed, 68 insertions, 63 deletions

diff --git a/chromium/content/browser/download/download_manager_impl_unittest.cc b/chromium/content/browser/download/download_manager_impl_unittest.cc
index 9d6350c3a93..9e297fe4f75 100644
--- a/chromium/content/browser/download/download_manager_impl_unittest.cc
+++ b/chromium/content/browser/download/download_manager_impl_unittest.cc
@@ -24,18 +24,18 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
+#include "components/download/public/common/download_create_info.h"
+#include "components/download/public/common/download_interrupt_reasons.h"
+#include "components/download/public/common/download_item.h"
+#include "components/download/public/common/download_request_handle_interface.h"
 #include "content/browser/byte_stream.h"
-#include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file_factory.h"
 #include "content/browser/download/download_item_factory.h"
 #include "content/browser/download/download_item_impl.h"
 #include "content/browser/download/download_item_impl_delegate.h"
-#include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/mock_download_file.h"
 #include "content/browser/download/mock_download_item_impl.h"
 #include "content/public/browser/browser_context.h"
-#include "content/public/browser/download_interrupt_reasons.h"
-#include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/test_browser_context.h"
@@ -71,12 +71,6 @@ class ByteStreamReader;
 
 namespace {
 
-// Matches a DownloadCreateInfo* that points to the same object as |info| and
-// has a |default_download_directory| that matches |download_directory|.
-MATCHER_P2(DownloadCreateInfoWithDefaultPath, info, download_directory, "") {
-  return arg == info && arg->default_download_directory == download_directory;
-}
-
 class MockDownloadManagerDelegate : public DownloadManagerDelegate {
  public:
   MockDownloadManagerDelegate();
@@ -85,13 +79,14 @@ class MockDownloadManagerDelegate : public DownloadManagerDelegate {
   MOCK_METHOD0(Shutdown, void());
   MOCK_METHOD1(GetNextId, void(const DownloadIdCallback&));
   MOCK_METHOD2(DetermineDownloadTarget,
-               bool(DownloadItem* item,
+               bool(download::DownloadItem* item,
                     const DownloadTargetCallback&));
   MOCK_METHOD1(ShouldOpenFileBasedOnExtension, bool(const base::FilePath&));
   MOCK_METHOD2(ShouldCompleteDownload,
-               bool(DownloadItem*, const base::Closure&));
+               bool(download::DownloadItem*, const base::Closure&));
   MOCK_METHOD2(ShouldOpenDownload,
-               bool(DownloadItem*, const DownloadOpenDelayedCallback&));
+               bool(download::DownloadItem*,
+                    const DownloadOpenDelayedCallback&));
   MOCK_METHOD4(GetSaveDir, void(BrowserContext*,
                                 base::FilePath*, base::FilePath*, bool*));
   MOCK_METHOD5(ChooseSavePath, void(
@@ -151,23 +146,26 @@ class MockDownloadItemFactory
       int64_t received_bytes,
       int64_t total_bytes,
       const std::string& hash,
-      DownloadItem::DownloadState state,
-      DownloadDangerType danger_type,
-      DownloadInterruptReason interrupt_reason,
+      download::DownloadItem::DownloadState state,
+      download::DownloadDangerType danger_type,
+      download::DownloadInterruptReason interrupt_reason,
       bool opened,
       base::Time last_access_time,
       bool transient,
-      const std::vector<DownloadItem::ReceivedSlice>& received_slices) override;
-  DownloadItemImpl* CreateActiveItem(DownloadItemImplDelegate* delegate,
-                                     uint32_t download_id,
-                                     const DownloadCreateInfo& info) override;
+      const std::vector<download::DownloadItem::ReceivedSlice>& received_slices)
+      override;
+  DownloadItemImpl* CreateActiveItem(
+      DownloadItemImplDelegate* delegate,
+      uint32_t download_id,
+      const download::DownloadCreateInfo& info) override;
   DownloadItemImpl* CreateSavePageItem(
       DownloadItemImplDelegate* delegate,
       uint32_t download_id,
       const base::FilePath& path,
       const GURL& url,
       const std::string& mime_type,
-      std::unique_ptr<DownloadRequestHandleInterface> request_handle) override;
+      std::unique_ptr<download::DownloadRequestHandleInterface> request_handle)
+      override;
 
  private:
   std::map<uint32_t, MockDownloadItemImpl*> items_;
@@ -228,13 +226,13 @@ DownloadItemImpl* MockDownloadItemFactory::CreatePersistedItem(
     int64_t received_bytes,
     int64_t total_bytes,
     const std::string& hash,
-    DownloadItem::DownloadState state,
-    DownloadDangerType danger_type,
-    DownloadInterruptReason interrupt_reason,
+    download::DownloadItem::DownloadState state,
+    download::DownloadDangerType danger_type,
+    download::DownloadInterruptReason interrupt_reason,
     bool opened,
     base::Time last_access_time,
     bool transient,
-    const std::vector<DownloadItem::ReceivedSlice>& received_slices) {
+    const std::vector<download::DownloadItem::ReceivedSlice>& received_slices) {
   DCHECK(items_.find(download_id) == items_.end());
   MockDownloadItemImpl* result =
       new StrictMock<MockDownloadItemImpl>(&item_delegate_);
@@ -248,7 +246,7 @@ DownloadItemImpl* MockDownloadItemFactory::CreatePersistedItem(
 DownloadItemImpl* MockDownloadItemFactory::CreateActiveItem(
     DownloadItemImplDelegate* delegate,
     uint32_t download_id,
-    const DownloadCreateInfo& info) {
+    const download::DownloadCreateInfo& info) {
   DCHECK(items_.find(download_id) == items_.end());
 
   MockDownloadItemImpl* result =
@@ -278,7 +276,7 @@ DownloadItemImpl* MockDownloadItemFactory::CreateSavePageItem(
     const base::FilePath& path,
     const GURL& url,
     const std::string& mime_type,
-    std::unique_ptr<DownloadRequestHandleInterface> request_handle) {
+    std::unique_ptr<download::DownloadRequestHandleInterface> request_handle) {
   DCHECK(items_.find(download_id) == items_.end());
 
   MockDownloadItemImpl* result =
@@ -299,11 +297,11 @@ class MockDownloadFileFactory
 
   // Overridden method from DownloadFileFactory
   MOCK_METHOD2(MockCreateFile,
-               MockDownloadFile*(const DownloadSaveInfo&,
+               MockDownloadFile*(const download::DownloadSaveInfo&,
                                  DownloadManager::InputStream*));
 
   DownloadFile* CreateFile(
-      std::unique_ptr<DownloadSaveInfo> save_info,
+      std::unique_ptr<download::DownloadSaveInfo> save_info,
       const base::FilePath& default_download_directory,
       std::unique_ptr<DownloadManager::InputStream> stream,
       uint32_t download_id,
@@ -371,8 +369,8 @@ class MockDownloadManagerObserver : public DownloadManager::Observer {
  public:
   MockDownloadManagerObserver() {}
   ~MockDownloadManagerObserver() {}
-  MOCK_METHOD2(OnDownloadCreated, void(
-        DownloadManager*, DownloadItem*));
+  MOCK_METHOD2(OnDownloadCreated,
+               void(DownloadManager*, download::DownloadItem*));
   MOCK_METHOD1(ManagerGoingDown, void(DownloadManager*));
   MOCK_METHOD2(SelectFileDialogDisplayed, void(DownloadManager*, int32_t));
 };
@@ -394,9 +392,10 @@ class DownloadManagerTest : public testing::Test {
 
   DownloadManagerTest()
       : callback_called_(false),
-        target_disposition_(DownloadItem::TARGET_DISPOSITION_OVERWRITE),
-        danger_type_(DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS),
-        interrupt_reason_(DOWNLOAD_INTERRUPT_REASON_NONE),
+        target_disposition_(
+            download::DownloadItem::TARGET_DISPOSITION_OVERWRITE),
+        danger_type_(download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS),
+        interrupt_reason_(download::DOWNLOAD_INTERRUPT_REASON_NONE),
         next_download_id_(0) {}
 
   // We tear down everything in TearDown().
@@ -439,7 +438,7 @@ class DownloadManagerTest : public testing::Test {
     while (MockDownloadItemImpl*
            item = mock_download_item_factory_->PopItem()) {
       EXPECT_CALL(*item, GetState())
-          .WillOnce(Return(DownloadItem::CANCELLED));
+          .WillOnce(Return(download::DownloadItem::CANCELLED));
     }
     EXPECT_CALL(GetMockObserver(), ManagerGoingDown(download_manager_.get()))
         .WillOnce(Return());
@@ -455,20 +454,19 @@ class DownloadManagerTest : public testing::Test {
 
   // Returns download id.
   MockDownloadItemImpl& AddItemToManager() {
-    DownloadCreateInfo info;
+    download::DownloadCreateInfo info;
 
     // Args are ignored except for download id, so everything else can be
     // null.
     uint32_t id = next_download_id_;
     ++next_download_id_;
-    info.request_handle.reset(new DownloadRequestHandle);
     download_manager_->CreateActiveItem(id, info);
     DCHECK(mock_download_item_factory_->GetItem(id));
     MockDownloadItemImpl& item(*mock_download_item_factory_->GetItem(id));
     // Satisfy expectation.  If the item is created in StartDownload(),
     // we call Start on it immediately, so we need to set that expectation
     // in the factory.
-    std::unique_ptr<DownloadRequestHandleInterface> req_handle;
+    std::unique_ptr<download::DownloadRequestHandleInterface> req_handle;
     item.Start(std::unique_ptr<DownloadFile>(), std::move(req_handle), info);
     DCHECK(id < download_urls_.size());
     EXPECT_CALL(item, GetURL()).WillRepeatedly(ReturnRef(download_urls_[id]));
@@ -498,10 +496,10 @@ class DownloadManagerTest : public testing::Test {
 
   void DownloadTargetDeterminedCallback(
       const base::FilePath& target_path,
-      DownloadItem::TargetDisposition disposition,
-      DownloadDangerType danger_type,
+      download::DownloadItem::TargetDisposition disposition,
+      download::DownloadDangerType danger_type,
       const base::FilePath& intermediate_path,
-      DownloadInterruptReason interrupt_reason) {
+      download::DownloadInterruptReason interrupt_reason) {
     callback_called_ = true;
     target_path_ = target_path;
     target_disposition_ = disposition;
@@ -529,10 +527,10 @@ class DownloadManagerTest : public testing::Test {
   // Target detetermined callback.
   bool callback_called_;
   base::FilePath target_path_;
-  DownloadItem::TargetDisposition target_disposition_;
-  DownloadDangerType danger_type_;
+  download::DownloadItem::TargetDisposition target_disposition_;
+  download::DownloadDangerType danger_type_;
   base::FilePath intermediate_path_;
-  DownloadInterruptReason interrupt_reason_;
+  download::DownloadInterruptReason interrupt_reason_;
 
   std::vector<GURL> download_urls_;
 
@@ -551,7 +549,8 @@ class DownloadManagerTest : public testing::Test {
 TEST_F(DownloadManagerTest, StartDownload) {
   SetHasObserverCalls(true);
 
-  std::unique_ptr<DownloadCreateInfo> info(new DownloadCreateInfo);
+  std::unique_ptr<download::DownloadCreateInfo> info(
+      new download::DownloadCreateInfo);
   std::unique_ptr<ByteStreamReader> stream(new MockByteStreamReader);
   uint32_t local_id(5);  // Random value
   base::FilePath download_path(FILE_PATH_LITERAL("download/path"));
@@ -577,8 +576,9 @@ TEST_F(DownloadManagerTest, StartDownload) {
               MockCreateFile(Ref(*info->save_info.get()), input_stream.get()))
       .WillOnce(Return(mock_file));
 
-  download_manager_->StartDownload(std::move(info), std::move(input_stream),
-                                   DownloadUrlParameters::OnStartedCallback());
+  download_manager_->StartDownload(
+      std::move(info), std::move(input_stream),
+      download::DownloadUrlParameters::OnStartedCallback());
   EXPECT_TRUE(download_manager_->GetDownload(local_id));
 
   SetHasObserverCalls(false);
@@ -590,7 +590,7 @@ TEST_F(DownloadManagerTest, DetermineDownloadTarget_True) {
   // Put a mock we have a handle to on the download manager.
   MockDownloadItemImpl& item(AddItemToManager());
   EXPECT_CALL(item, GetState())
-      .WillRepeatedly(Return(DownloadItem::IN_PROGRESS));
+      .WillRepeatedly(Return(download::DownloadItem::IN_PROGRESS));
 
   EXPECT_CALL(GetMockDownloadManagerDelegate(),
               DetermineDownloadTarget(&item, _))
@@ -615,10 +615,11 @@ TEST_F(DownloadManagerTest, DetermineDownloadTarget_False) {
   DetermineDownloadTarget(&item);
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(path, target_path_);
-  EXPECT_EQ(DownloadItem::TARGET_DISPOSITION_OVERWRITE, target_disposition_);
-  EXPECT_EQ(DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, danger_type_);
+  EXPECT_EQ(download::DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+            target_disposition_);
+  EXPECT_EQ(download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, danger_type_);
   EXPECT_EQ(path, intermediate_path_);
-  EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason_);
+  EXPECT_EQ(download::DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason_);
 }
 
 TEST_F(DownloadManagerTest, GetDownloadByGuid) {
@@ -626,22 +627,26 @@ TEST_F(DownloadManagerTest, GetDownloadByGuid) {
     AddItemToManager();
 
   MockDownloadItemImpl& item = GetMockDownloadItem(0);
-  DownloadItem* result = download_manager_->GetDownloadByGuid(item.GetGuid());
+  download::DownloadItem* result =
+      download_manager_->GetDownloadByGuid(item.GetGuid());
   ASSERT_TRUE(result);
-  ASSERT_EQ(static_cast<DownloadItem*>(&item), result);
+  ASSERT_EQ(static_cast<download::DownloadItem*>(&item), result);
 
   ASSERT_FALSE(download_manager_->GetDownloadByGuid(""));
 
   const char kGuid[] = "8DF158E8-C980-4618-BB03-EBA3242EB48B";
-  DownloadItem* persisted_item = download_manager_->CreateDownloadItem(
-      kGuid, 10, base::FilePath(), base::FilePath(), std::vector<GURL>(),
-      GURL("http://example.com/a"), GURL("http://example.com/a"),
-      GURL("http://example.com/a"), GURL("http://example.com/a"),
-      "application/octet-stream", "application/octet-stream", base::Time::Now(),
-      base::Time::Now(), std::string(), std::string(), 10, 10, std::string(),
-      DownloadItem::INTERRUPTED, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-      DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED, false, base::Time::Now(), true,
-      std::vector<DownloadItem::ReceivedSlice>());
+  download::DownloadItem* persisted_item =
+      download_manager_->CreateDownloadItem(
+          kGuid, 10, base::FilePath(), base::FilePath(), std::vector<GURL>(),
+          GURL("http://example.com/a"), GURL("http://example.com/a"),
+          GURL("http://example.com/a"), GURL("http://example.com/a"),
+          "application/octet-stream", "application/octet-stream",
+          base::Time::Now(), base::Time::Now(), std::string(), std::string(),
+          10, 10, std::string(), download::DownloadItem::INTERRUPTED,
+          download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+          download::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED, false,
+          base::Time::Now(), true,
+          std::vector<download::DownloadItem::ReceivedSlice>());
   ASSERT_TRUE(persisted_item);
 
   ASSERT_EQ(persisted_item, download_manager_->GetDownloadByGuid(kGuid));
@@ -663,7 +668,7 @@ TEST_F(DownloadManagerTest, RemoveDownloadsByURL) {
     MockDownloadItemImpl& item(AddItemToManager());
     EXPECT_CALL(item, GetStartTime()).WillRepeatedly(Return(now));
     EXPECT_CALL(item, GetState())
-        .WillRepeatedly(Return(DownloadItem::COMPLETE));
+        .WillRepeatedly(Return(download::DownloadItem::COMPLETE));
   }
 
   EXPECT_CALL(GetMockDownloadItem(0), Remove());