Refactor download image-MIME-type-detection code.

chrome/browser/download/download_item_model_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_item_model.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
@@ skipping 12 matching lines @@
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/text/bytes_formatting.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/text_utils.h"
 
 using content::DownloadItem;
 using safe_browsing::DownloadFileType;
 using ::testing::Mock;
 using ::testing::NiceMock;
 using ::testing::Return;
+using ::testing::ReturnRef;
 using ::testing::ReturnRefOfCopy;
 using ::testing::SetArgPointee;
 using ::testing::_;
 
 namespace {
 
 // Create a char array that has as many elements as there are download
 // interrupt reasons. We can then use that in a static_assert to make sure
 // that all the interrupt reason codes are accounted for. The reason codes are
 // unfortunately sparse, making this necessary.
@@ skipping 332 matching lines @@
 TEST_F(DownloadItemModelTest, DangerLevel) {
   SetupDownloadItemDefaults();
 
   // Default danger level is NOT_DANGEROUS.
   EXPECT_EQ(DownloadFileType::NOT_DANGEROUS, model().GetDangerLevel());
 
   model().SetDangerLevel(DownloadFileType::ALLOW_ON_USER_GESTURE);
   EXPECT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE, model().GetDangerLevel());
 }
 
+TEST_F(DownloadItemModelTest, HasSupportedImageMimeType) {
+  SetupDownloadItemDefaults();
+
+  // When the item has a supported image MIME type, true should be returned.
+  ON_CALL(item(), GetMimeType()).WillByDefault(Return("image/png"));
+  EXPECT_TRUE(model().HasSupportedImageMimeType());
+
+  // An unsupported MIME type should result in false being returned...
+  ON_CALL(item(), GetMimeType()).WillByDefault(Return("image/unsupported"));
+  EXPECT_FALSE(model().HasSupportedImageMimeType());
+
+  // ... unless the target path has a well-known image extension.
+  const base::FilePath kImagePath(FILE_PATH_LITERAL("/foo/image.png"));
+  ON_CALL(item(), GetTargetFilePath()).WillByDefault(ReturnRef(kImagePath));
+  EXPECT_TRUE(model().HasSupportedImageMimeType());
+
+  // .txt and missing extensions should also result in false being returned.
+  const base::FilePath kTextPath(FILE_PATH_LITERAL("/foo/image.txt"));
+  ON_CALL(item(), GetTargetFilePath()).WillByDefault(ReturnRef(kTextPath));
+  EXPECT_FALSE(model().HasSupportedImageMimeType());
+
+  const base::FilePath kNoExtensionPath(FILE_PATH_LITERAL("/foo/image."));
+  ON_CALL(item(), GetTargetFilePath())
+      .WillByDefault(ReturnRef(kNoExtensionPath));
+  EXPECT_FALSE(model().HasSupportedImageMimeType());
+}
+
 TEST_F(DownloadItemModelTest, ShouldRemoveFromShelfWhenComplete) {
   const struct TestCase {
     DownloadItem::DownloadState state;
     bool is_dangerous;  // Expectation for IsDangerous().
     bool is_auto_open;  // Expectation for GetOpenWhenComplete().
     bool auto_opened;   // Whether the download was successfully
                         // auto-opened. Expecation for GetAutoOpened().
     bool expected_result;
   } kTestCases[] = {
     // All the valid combinations of state, is_dangerous, is_auto_open and
@@ skipping 34 matching lines @@
     EXPECT_CALL(item(), GetAutoOpened())
         .WillRepeatedly(Return(test_case.auto_opened));
 
     EXPECT_EQ(test_case.expected_result,
               model().ShouldRemoveFromShelfWhenComplete())
         << "Test case: " << i;
     Mock::VerifyAndClearExpectations(&item());
     Mock::VerifyAndClearExpectations(&model());
   }
 }