[SafeBrowsing] Alternate extensions should also be subject to block list.

chrome/browser/file_select_helper.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/file_select_helper.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 424 matching lines @@
   // Because this class returns notifications to the RenderViewHost, it is
   // difficult for callers to know how long to keep a reference to this
   // instance. We AddRef() here to keep the instance alive after we return
   // to the caller, until the last callback is received from the file dialog.
   // At that point, we must call RunFileChooserEnd().
   AddRef();
 }
 
 void FileSelectHelper::GetFileTypesOnFileThread(
     scoped_ptr<FileChooserParams> params) {
   select_file_types_ = GetFileTypesFromAcceptType(params->accept_types);

[Nathan Parker, 2016/01/21 01:32:26]

Do we know how often this contains multiple items?  It might be good to have an
UMA metric (could be in CheckUnverifiedDownloadPolicy) to know how often we're
expanding the list.  I'm thinking, if it often tacks on .xml or something, and
we end up blocking every file type.

[asanka, 2016/01/21 01:37:10]

We don't have data for how often we get multiple file types. I've modified the
code in CheckUnverifiedDownloadPolicy to report the file type that caused the
request to be disallowed instead of the file type of the suggested file name. I
can also add a measurement for the number of alternate extensions we see if you
think this isn't enough.

[Nathan Parker, 2016/01/21 17:11:14]

Yea to gauge the order of magnitude of how often this fires, I think we should
log a histogram of number of entries in the select_file_types_.  I think the
logging of _blocked_ filetype is the right thing.

   select_file_types_->support_drive = !params->need_local_path;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&FileSelectHelper::GetSanitizedFilenameOnUIThread, this,
                  base::Passed(&params)));
 }
 
 void FileSelectHelper::GetSanitizedFilenameOnUIThread(
     scoped_ptr<FileChooserParams> params) {
   base::FilePath default_file_path = profile_->last_selected_directory().Append(
       GetSanitizedFileName(params->default_file_name));
 
 #if defined(FULL_SAFE_BROWSING)
+  std::vector<base::FilePath::StringType> alternate_extensions;
+  if (select_file_types_) {
+    for (const auto& extensions : select_file_types_->extensions) {

[sky, 2016/01/21 20:13:15]

Isn't this the same as alternate_extensions = select_file_types_->extensions ?

[asanka, 2016/01/21 20:25:34]

select_file_types_->extensions is a vector<vector<FilePath::StringType >>.

This loop is flattening the list into a vector<FilePath::StringType> by
concatenating all the vector<FilePath::StringType> elements in
select_file_type_->extensions.

+      alternate_extensions.insert(alternate_extensions.end(),
+                                  extensions.begin(), extensions.end());
+    }
+  }
+
   // Note that FileChooserParams::requestor is not considered a trusted field
   // since it's provided by the renderer and not validated browserside.
   if (params->mode == FileChooserParams::Save &&
-      !params->default_file_name.empty()) {
+      (!params->default_file_name.empty() || !alternate_extensions.empty())) {
     GURL requestor = params->requestor;
     safe_browsing::CheckUnverifiedDownloadPolicy(
-        requestor, default_file_path,
+        requestor, default_file_path, alternate_extensions,
         base::Bind(&FileSelectHelper::ApplyUnverifiedDownloadPolicy, this,
                    default_file_path, base::Passed(&params)));
     return;
   }
 #endif
 
   RunFileChooserOnUIThread(default_file_path, std::move(params));
 }
 
 #if defined(FULL_SAFE_BROWSING)
@@ skipping 150 matching lines @@
 
 // static
 base::FilePath FileSelectHelper::GetSanitizedFileName(
     const base::FilePath& suggested_filename) {
   if (suggested_filename.empty())
     return base::FilePath();
   return net::GenerateFileName(
       GURL(), std::string(), std::string(), suggested_filename.AsUTF8Unsafe(),
       std::string(), l10n_util::GetStringUTF8(IDS_DEFAULT_DOWNLOAD_FILENAME));
 }