Fix dragging supported files to tab strip.

chrome/browser/ui/views/tabs/tab_strip.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/ui/views/tabs/tab_strip.h"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
 #include <algorithm>
 #include <iterator>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_runner_util.h"
 #include "chrome/browser/defaults.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/tabs/stacked_tab_strip_layout.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 #include "chrome/browser/ui/views/tabs/tab_strip_controller.h"
 #include "chrome/browser/ui/views/tabs/tab_strip_observer.h"
 #include "chrome/browser/ui/views/touch_uma/touch_uma.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/plugin_service.h"
 #include "content/public/browser/user_metrics.h"
+#include "content/public/common/webplugininfo.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
+#include "ipc/ipc_message.h"
+#include "net/base/net_util.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/default_theme_provider.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/animation/animation_container.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
@@ skipping 240 matching lines @@
   views::View::ConvertPointToTarget(source, dest, &dest_point);
   return dest->GetTooltipHandlerForPoint(dest_point);
 }
 
 TabDragController::EventSource EventSourceFromEvent(
     const ui::LocatedEvent& event) {
   return event.IsGestureEvent() ? TabDragController::EVENT_SOURCE_TOUCH :
       TabDragController::EVENT_SOURCE_MOUSE;
 }
 
+// Get the MIME type of the file pointed to by the url. This must be called
+// from an thread that allows IO.
+std::string FindURLMimeType(GURL url) {
+  base::FilePath full_path;
+  net::FileURLToFilePath(url, &full_path);
+
+  std::string mime_type;
+  // Get the MIME type based on the file path's extension.
+  // This may use registry or file IO.
+  net::GetMimeTypeFromFile(full_path, &mime_type);
+
+  return mime_type;
+}
+
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // NewTabButton
 //
 //  A subclass of button that hit-tests to the shape of the new tab button and
 //  does custom drawing.
 
 class NewTabButton : public views::ImageButton {
  public:
@@ skipping 299 matching lines @@
 // static
 const int TabStrip::kMiniToNonMiniGap = 3;
 
 TabStrip::TabStrip(TabStripController* controller)
     : controller_(controller),
       newtab_button_(NULL),
       current_unselected_width_(Tab::GetStandardSize().width()),
       current_selected_width_(Tab::GetStandardSize().width()),
       available_width_for_tabs_(-1),
       in_tab_close_(false),
+      drag_file_supported_(true),
       animation_container_(new gfx::AnimationContainer()),
       bounds_animator_(this),
       layout_type_(TAB_STRIP_LAYOUT_SHRINK),
       adjust_layout_(false),
       reset_to_shrink_on_exit_(false),
       mouse_move_count_(0),
-      immersive_style_(false) {
+      immersive_style_(false),
+      weak_ptr_factory_(this) {
   Init();
 }
 
 TabStrip::~TabStrip() {
   FOR_EACH_OBSERVER(TabStripObserver, observers_,
                     TabStripDeleted(this));
 
   // The animations may reference the tabs. Shut down the animation before we
   // delete the tabs.
   StopAnimating(false);
@@ skipping 759 matching lines @@
   } else {
     needed_width = Tab::GetMinimumSelectedSize().width();
   }
   needed_width += new_tab_button_width();
   if (immersive_style_)
     return gfx::Size(needed_width, Tab::GetImmersiveHeight());
   return gfx::Size(needed_width, Tab::GetMinimumUnselectedSize().height());
 }
 
 void TabStrip::OnDragEntered(const DropTargetEvent& event) {
+  // Clear information about previous drag operation.
+  drag_url_ = GURL();
+  drag_file_supported_ = true;
+
+  GURL url;
+  string16 title;
+  if (event.data().GetURLAndTitle(&url, &title) && url.is_valid()) {

[asanka, 2013/11/15 19:15:22]

The logic below here only applies to file:// URLs. For other schemes, we'll have
to assume that the URL is supported since the MIME type won't be known until the
request has been issued.

[sky, 2013/11/15 20:46:37]

None-the-less there is no point doing the same test as is done @ 1473. 

[asanka, 2013/11/15 21:01:13]

Yup.

[michaelpg, 2013/11/15 21:08:01]

The check here esnures we don't request unnecessary IO. asanka@ is right that I
should add the condition url.SchemaIsFile() to this if statement.

drop_data_supported_ defaults to true, so for non-file-schema URLs, the check at
1473 will still be necessary.... unless I set drag_file_supported to false in an
else statement here, regardless of the schema. Which makes sense now that I
think about it.

+    // Cache the URL associated with the current drag.
+    drag_url_ = url;
+
+    // Get the MIME type of the file based on the file path's extension.
+    // Pass the input URL to be certain which URL the reply is for.
+    base::PostTaskAndReplyWithResult(
+        content::BrowserThread::GetBlockingPool(),
+        FROM_HERE,
+        base::Bind(&FindURLMimeType, url),
+        base::Bind(&TabStrip::OnFindURLMimeTypeCompleted,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   url));
+  }
+
   // Force animations to stop, otherwise it makes the index calculation tricky.
   StopAnimating(true);
 
   UpdateDropIndex(event);
 }
 
 int TabStrip::OnDragUpdated(const DropTargetEvent& event) {
   UpdateDropIndex(event);
+
+  if (!drag_file_supported_)
+    return ui::DragDropTypes::DRAG_NONE;
+
   return GetDropEffect(event);
 }
 
 void TabStrip::OnDragExited() {
   SetDropIndex(-1, false);
 }
 
 int TabStrip::OnPerformDrop(const DropTargetEvent& event) {
   if (!drop_info_.get())
     return ui::DragDropTypes::DRAG_NONE;
 
   const int drop_index = drop_info_->drop_index;
   const bool drop_before = drop_info_->drop_before;
 
   // Hide the drop indicator.
   SetDropIndex(-1, false);
 
   GURL url;
   string16 title;
-  if (!event.data().GetURLAndTitle(&url, &title) || !url.is_valid())
+  if (!drag_file_supported_ || !event.data().GetURLAndTitle(&url, &title) ||

[sky, 2013/11/15 00:48:54]

We shouldn't need to check url/title twice.

[michaelpg, 2013/11/18 23:24:51]

Done, as per above.

+      !url.is_valid())
     return ui::DragDropTypes::DRAG_NONE;
 
   controller()->PerformDrop(drop_before, drop_index, url);
 
   return GetDropEffect(event);
 }
 
 void TabStrip::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_PAGETABLIST;
 }
@@ skipping 597 matching lines @@
     GenerateIdealBounds();
     AnimateToIdealBounds();
   }
   bounds_animator_.AnimateViewTo(tab, ideal_bounds(tab_data_index));
   // Install a delegate to reset the dragging state when done. We have to leave
   // dragging true for the tab otherwise it'll draw beneath the new tab button.
   bounds_animator_.SetAnimationDelegate(
       tab, new ResetDraggingStateDelegate(tab), true);
 }
 
+void TabStrip::OnFindURLMimeTypeCompleted(GURL url,
+                                          const std::string& mime_type) {
+  // If this is a reply for the current URL, check if the file is unsupported.
+  // If the MIME type is empty, we do not have enough info to disallow the drag.
+  if (url == drag_url_ && !mime_type.empty() &&
+      !net::IsSupportedMimeType(mime_type)) {
+    // Check whether there is a plugin that supports the mime type (e.g. PDF).
+    // TODO(bauerb): This possibly uses stale information, but it's guaranteed
+    // not to do disk access.
+    bool allow_wildcard = false;
+    content::WebPluginInfo plugin;
+    if (!content::PluginService::GetInstance()->GetPluginInfo(
+            -1,                // process ID
+            MSG_ROUTING_NONE,  // routing ID
+            controller()->GetProfile()->GetResourceContext(),
+            url, GURL(), mime_type, allow_wildcard,
+            NULL, &plugin, NULL))
+      drag_file_supported_ = false;
+  }
+}
+
 void TabStrip::OwnDragController(TabDragController* controller) {
   // Typically, ReleaseDragController() and OwnDragController() calls are paired
   // via corresponding calls to TabDragController::Detach() and
   // TabDragController::Attach(). There is one exception to that rule: when a
   // drag might start, we create a TabDragController that is owned by the
   // potential source tabstrip in MaybeStartDrag(). If a drag actually starts,
   // we then call Attach() on the source tabstrip, but since the source tabstrip
   // already owns the TabDragController, so we don't need to do anything.
   if (controller != drag_controller_.get())
     drag_controller_.reset(controller);
@@ skipping 678 matching lines @@
 #if defined(USE_AURA)
   return chrome::GetHostDesktopTypeForNativeView(
       GetWidget()->GetNativeView()) == chrome::HOST_DESKTOP_TYPE_ASH;
 #else
   if (ui::GetDisplayLayout() != ui::LAYOUT_TOUCH)
     return false;
 #endif
 
   return true;
 }