Upstream Chrome on iOS source code [6/11].

ios/chrome/browser/ui/open_in_controller.mm

+// Copyright 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.
+
+#import "ios/chrome/browser/ui/open_in_controller.h"
+
+#include "base/files/file_path.h"
+#include "base/ios/weak_nsobject.h"
+#include "base/location.h"
+#include "base/logging.h"
+#import "base/mac/bind_objc_block.h"
+#include "base/mac/objc_property_releaser.h"
+#include "base/sequenced_task_runner.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/thread_restrictions.h"
+#include "components/strings/grit/components_strings.h"
+#import "ios/chrome/browser/ui/alert_coordinator/alert_coordinator.h"
+#import "ios/chrome/browser/ui/open_in_controller_testing.h"
+#include "ios/chrome/browser/ui/ui_util.h"
+#import "ios/chrome/browser/ui/uikit_ui_util.h"
+#include "ios/chrome/grit/ios_strings.h"
+#include "ios/web/public/web_thread.h"
+#import "ios/web/web_state/ui/crw_web_controller.h"
+#include "net/base/load_flags.h"
+#include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_fetcher_delegate.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "ui/base/l10n/l10n_util_mac.h"
+#import "ui/gfx/ios/NSString+CrStringDrawing.h"
+#include "url/gurl.h"
+
+namespace {
+// The path in the temp directory containing documents that are to be opened in
+// other applications.
+static NSString* const kDocumentsTempPath = @"OpenIn";
+
+static const int kHTTPResponseCodeSucceeded = 200;
+
+// Duration of the show/hide animation for the |openInToolbar_|.
+const NSTimeInterval kOpenInToolbarAnimationDuration = 0.2;
+
+// Duration to show or hide the |overlayedView_|.
+const NSTimeInterval kOverlayViewAnimationDuration = 0.3;
+
+// Time interval after which the |openInToolbar_| is automatically hidden.
+const NSTimeInterval kOpenInToolbarDisplayDuration = 2.0;
+
+// Text size used for the label indicating a download in progress.
+const CGFloat kLabelTextSize = 22.0;
+
+// Alpha value for the background view of |overlayedView_|.
+const CGFloat kOverlayedViewBackgroundAlpha = 0.6;
+
+// Width of the label displayed on the |overlayedView_| as a percentage of the
+// |overlayedView_|'s width.
+const CGFloat kOverlayedViewLabelWidthPercentage = 0.7;
+
+// Bottom margin for the label displayed on the |overlayedView_|.
+const CGFloat kOverlayedViewLabelBottomMargin = 60;
+
+}  // anonymous namespace
+
+@interface OpenInController () {
+  // AlertCoordinator for showing an alert if no applications were found to open
+  // the current document.
+  base::scoped_nsobject<AlertCoordinator> _alertCoordinator;
+}
+
+// URLFetcher delegate method called when |fetcher_| completes a request.
+- (void)urlFetchDidComplete:(const net::URLFetcher*)source;
+// Ensures the destination directory is created and any contained obsolete files
+// are deleted. Returns YES if the directory is created successfully.
++ (BOOL)createDestinationDirectoryAndRemoveObsoleteFiles;
+// Starts downloading the file at path |kDocumentsTempPath| with the name
+// |suggestedFilename_|.
+- (void)startDownload;
+// Shows the overlayed toolbar |openInToolbar_|.
+- (void)showOpenInToolbar;
+// Hides the overlayed toolbar |openInToolbar_|.
+- (void)hideOpenInToolbar;
+// Called when there is a tap on the |webController_|'s view to display the
+// overlayed toolbar |openInToolbar_| if necessary and (re)schedule the
+// |openInTimer_|.
+- (void)handleTapFrom:(UIGestureRecognizer*)gestureRecognizer;
+// Downloads the file at |documentURL_| and presents the OpenIn menu for opening
+// it in other applications.
+- (void)exportFileWithOpenInMenuAnchoredAt:(id)sender;
+// Called when there is a tap on the |overlayedView_| to cancel the file
+// download.
+- (void)handleTapOnOverlayedView:(UIGestureRecognizer*)gestureRecognizer;
+// Removes |overlayedView_| from the top view of the application.
+- (void)removeOverlayedView;
+// Shows an alert with the given error message.
+- (void)showErrorWithMessage:(NSString*)message;
+// Presents the OpenIn menu for the file at |fileURL|.
+- (void)presentOpenInMenuForFileAtURL:(NSURL*)fileURL;
+// Removes the file at path |path|.
+- (void)removeDocumentAtPath:(NSString*)path;
+// Removes all the stored files at path |path|.
++ (void)removeAllStoredDocumentsAtPath:(NSString*)path;
+// Shows an overlayed spinner on the top view to indicate that a file download
+// is in progress.
+- (void)showDownloadOverlayView;
+// Returns a toolbar with an "Open in..." button to be overlayed on a document
+// on tap.
+- (UIToolbar*)openInToolbar;
+@end
+
+// Bridge to deliver method calls from C++ to the |OpenInController| class.
+class OpenInControllerBridge
+    : public net::URLFetcherDelegate,
+      public base::RefCountedThreadSafe<OpenInControllerBridge> {
+ public:
+  explicit OpenInControllerBridge(OpenInController* owner) : owner_(owner) {}
+
+  void OnURLFetchComplete(const net::URLFetcher* source) override {
+    DCHECK(owner_);
+    [owner_ urlFetchDidComplete:source];
+  }
+
+  BOOL CreateDestinationDirectoryAndRemoveObsoleteFiles(void) {
+    return [OpenInController createDestinationDirectoryAndRemoveObsoleteFiles];
+  }
+
+  void OnDestinationDirectoryCreated(BOOL success) {
+    DCHECK_CURRENTLY_ON(web::WebThread::UI);
+    if (!success)
+      [owner_ hideOpenInToolbar];
+    else
+      [owner_ startDownload];
+  }
+
+  void OnOwnerDisabled() {
+    // When the owner is disabled:
+    // - if there is a task in flight posted via |PostTaskAndReplyWithResult|
+    // then dereferencing |bridge_| will not release it as |bridge_| is also
+    // referenced by the task posting; setting |owner_| to nil makes sure that
+    // no methods are called on it, and it works since |owner_| is only used on
+    // the main thread.
+    // - if there is a task in flight posted by the URLFetcher then
+    // |OpenInController| destroys the fetcher and cancels the callback. This is
+    // why |OnURLFetchComplete| will neved be called after |owner_| is disabled.
+    owner_ = nil;
+  }
+
+ protected:
+  friend base::RefCountedThreadSafe<OpenInControllerBridge>;
+  ~OpenInControllerBridge() override {}
+
+ private:
+  OpenInController* owner_;  // weak
+};
+
+@implementation OpenInController {
+  // Bridge from C++ to Obj-C class.
+  scoped_refptr<OpenInControllerBridge> bridge_;
+
+  // URL of the document.
+  GURL documentURL_;
+
+  // Controller for opening documents in other applications.
+  base::scoped_nsobject<UIDocumentInteractionController> documentController_;
+
+  // Toolbar overlay to be displayed on tap.
+  base::scoped_nsobject<OpenInToolbar> openInToolbar_;
+
+  // Timer used to automatically hide the |openInToolbar_| after a period.
+  base::scoped_nsobject<NSTimer> openInTimer_;
+
+  // Gesture recognizer to catch taps on the document.
+  base::scoped_nsobject<UITapGestureRecognizer> tapRecognizer_;
+
+  // Suggested filename for the document.
+  base::scoped_nsobject<NSString> suggestedFilename_;
+
+  // Fetcher used to redownload the document and save it in the sandbox.
+  std::unique_ptr<net::URLFetcher> fetcher_;
+
+  // CRWWebController used to check if the tap is not on a link and the
+  // |openInToolbar_| should be displayed.
+  base::scoped_nsobject<CRWWebController> webController_;
+
+  // URLRequestContextGetter needed for the URLFetcher.
+  scoped_refptr<net::URLRequestContextGetter> requestContext_;
+
+  // Spinner view displayed while the file is downloading.
+  base::scoped_nsobject<UIView> overlayedView_;
+
+  // The location where the "Open in..." menu is anchored.
+  CGRect anchorLocation_;
+
+  // YES if the file download was canceled.
+  BOOL downloadCanceled_;
+
+  // YES if the OpenIn menu is displayed.
+  BOOL isOpenInMenuDisplayed_;
+
+  // Task runner on which file operations should happen.
+  scoped_refptr<base::SequencedTaskRunner> sequencedTaskRunner_;
+
+  base::mac::ObjCPropertyReleaser propertyReleaser_OpenInController_;
+}
+
+- (id)initWithRequestContext:(net::URLRequestContextGetter*)requestContext
+               webController:(CRWWebController*)webController {
+  self = [super init];
+  if (self) {
+    requestContext_ = requestContext;
+    webController_.reset([webController retain]);
+    tapRecognizer_.reset([[UITapGestureRecognizer alloc]
+        initWithTarget:self
+                action:@selector(handleTapFrom:)]);
+    [tapRecognizer_ setDelegate:self];
+    base::SequencedWorkerPool* pool = web::WebThread::GetBlockingPool();
+    sequencedTaskRunner_ =
+        pool->GetSequencedTaskRunner(pool->GetSequenceToken());
+    isOpenInMenuDisplayed_ = NO;
+    propertyReleaser_OpenInController_.Init(self, [OpenInController class]);
+  }
+  return self;
+}
+
+- (void)enableWithDocumentURL:(const GURL&)documentURL
+            suggestedFilename:(NSString*)suggestedFilename {
+  documentURL_ = GURL(documentURL);
+  suggestedFilename_.reset([suggestedFilename retain]);
+  [webController_ addGestureRecognizerToWebView:tapRecognizer_];
+  [self openInToolbar].alpha = 0.0f;
+  [webController_ addToolbarViewToWebView:[self openInToolbar]];
+}
+
+- (void)disable {
+  [self openInToolbar].alpha = 0.0f;
+  [openInTimer_ invalidate];
+  if (bridge_.get())
+    bridge_->OnOwnerDisabled();
+  bridge_ = nil;
+  [webController_ removeGestureRecognizerFromWebView:tapRecognizer_];
+  [webController_ removeToolbarViewFromWebView:[self openInToolbar]];
+  [documentController_ dismissMenuAnimated:NO];
+  [documentController_ setDelegate:nil];
+  documentURL_ = GURL();
+  suggestedFilename_.reset();
+  fetcher_.reset();
+}
+
+- (void)detachFromWebController {
+  [self disable];
+  // Animation blocks may be keeping this object alive; don't extend the
+  // lifetime of CRWWebController.
+  webController_.reset();
+}
+
+- (void)dealloc {
+  [self disable];
+  [super dealloc];
+}
+
+- (void)handleTapFrom:(UIGestureRecognizer*)gestureRecognizer {
+  if ([gestureRecognizer state] == UIGestureRecognizerStateEnded) {
+    [self showOpenInToolbar];
+  }
+}
+
+- (void)showOpenInToolbar {
+  if ([openInTimer_ isValid]) {
+    [openInTimer_ setFireDate:([NSDate dateWithTimeIntervalSinceNow:
+                                           kOpenInToolbarDisplayDuration])];
+  } else {
+    openInTimer_.reset(
+        [[NSTimer scheduledTimerWithTimeInterval:kOpenInToolbarDisplayDuration
+                                          target:self
+                                        selector:@selector(hideOpenInToolbar)
+                                        userInfo:nil
+                                         repeats:NO] retain]);
+    UIView* openInToolbar = [self openInToolbar];
+    [UIView animateWithDuration:kOpenInToolbarAnimationDuration
+                     animations:^{
+                       [openInToolbar setAlpha:1.0];
+                     }];
+  }
+}
+
+- (void)hideOpenInToolbar {
+  if (!openInToolbar_)
+    return;
+  UIView* openInToolbar = [self openInToolbar];
+  [UIView animateWithDuration:kOpenInToolbarAnimationDuration
+                   animations:^{
+                     [openInToolbar setAlpha:0.0];
+                   }];
+}
+
+- (void)exportFileWithOpenInMenuAnchoredAt:(UIView*)view {
+  DCHECK([view isKindOfClass:[UIView class]]);
+  DCHECK_CURRENTLY_ON(web::WebThread::UI);
+  if (!webController_)
+    return;
+
+  anchorLocation_ = [[self openInToolbar] convertRect:view.frame
+                                               toView:[webController_ view]];
+  [openInTimer_ invalidate];
+  if (!bridge_.get())
+    bridge_ = new OpenInControllerBridge(self);
+
+  // This needs to be done in two steps, on two separate threads. The
+  // first task needs to be done on the worker pool and returns a BOOL which is
+  // then used in the second function, |OnDestinationDirectoryCreated|, which
+  // runs on the UI thread.
+  base::Callback<BOOL(void)> task = base::Bind(
+      &OpenInControllerBridge::CreateDestinationDirectoryAndRemoveObsoleteFiles,
+      bridge_);
+  base::Callback<void(BOOL)> reply = base::Bind(
+      &OpenInControllerBridge::OnDestinationDirectoryCreated, bridge_);
+  base::PostTaskAndReplyWithResult(sequencedTaskRunner_.get(), FROM_HERE, task,
+                                   reply);
+}
+
+- (void)startDownload {
+  NSString* tempDirPath = [NSTemporaryDirectory()
+      stringByAppendingPathComponent:kDocumentsTempPath];
+  NSString* filePath =
+      [tempDirPath stringByAppendingPathComponent:suggestedFilename_.get()];
+
+  // In iPad the toolbar has to be displayed to anchor the "Open in" menu.
+  if (!IsIPadIdiom())
+    [self hideOpenInToolbar];
+
+  // Show an overlayed view to indicate a download is in progress. On tap this
+  // view can be dismissed and the download canceled.
+  [self showDownloadOverlayView];
+  downloadCanceled_ = NO;
+
+  // Ensure |bridge_| is set in case this function is called from a unittest.
+  if (!bridge_.get())
+    bridge_ = new OpenInControllerBridge(self);
+
+  // Download the document and save it at |filePath|.
+  fetcher_ = net::URLFetcher::Create(0, documentURL_, net::URLFetcher::GET,
+                                     bridge_.get());
+  fetcher_->SetRequestContext(requestContext_.get());
+  fetcher_->SetLoadFlags(net::LOAD_SKIP_CACHE_VALIDATION);
+  fetcher_->SaveResponseToFileAtPath(
+      base::FilePath(base::SysNSStringToUTF8(filePath)), sequencedTaskRunner_);
+  fetcher_->Start();
+}
+
+- (void)handleTapOnOverlayedView:(UIGestureRecognizer*)gestureRecognizer {
+  if ([gestureRecognizer state] != UIGestureRecognizerStateEnded)
+    return;
+
+  [self removeOverlayedView];
+  if (IsIPadIdiom())
+    [self hideOpenInToolbar];
+  downloadCanceled_ = YES;
+}
+
+- (void)removeOverlayedView {
+  if (!overlayedView_)
+    return;
+
+  UIView* overlayedView = overlayedView_.get();
+  [UIView animateWithDuration:kOverlayViewAnimationDuration
+      animations:^{
+        [overlayedView setAlpha:0.0];
+      }
+      completion:^(BOOL finished) {
+        [overlayedView removeFromSuperview];
+      }];
+  overlayedView_.reset();
+}
+
+- (void)showErrorWithMessage:(NSString*)message {
+  UIViewController* topViewController =
+      [[[UIApplication sharedApplication] keyWindow] rootViewController];
+
+  _alertCoordinator.reset([[AlertCoordinator alloc]
+      initWithBaseViewController:topViewController
+                           title:nil
+                         message:message]);
+
+  [_alertCoordinator addItemWithTitle:l10n_util::GetNSString(IDS_OK)
+                               action:nil
+                                style:UIAlertActionStyleDefault];
+
+  [_alertCoordinator start];
+}
+
+- (void)presentOpenInMenuForFileAtURL:(NSURL*)fileURL {
+  if (!webController_)
+    return;
+
+  if (requestContext_.get()) {
+    // |requestContext_| is nil only if this is called from a unit test, in
+    // which case the |documentController_| was set already.
+    documentController_.reset([[UIDocumentInteractionController
+        interactionControllerWithURL:fileURL] retain]);
+  }
+
+  // TODO(cgrigoruta): The UTI is hardcoded for now, change this when we add
+  // support for other file types as well.
+  [documentController_ setUTI:@"com.adobe.pdf"];
+  [documentController_ setDelegate:self];
+  BOOL success =
+      [documentController_ presentOpenInMenuFromRect:anchorLocation_
+                                              inView:[webController_ view]
+                                            animated:YES];
+  if (requestContext_.get()) {
+    [self removeOverlayedView];
+    if (!success) {
+      if (IsIPadIdiom())
+        [self hideOpenInToolbar];
+      NSString* errorMessage =
+          l10n_util::GetNSStringWithFixup(IDS_IOS_OPEN_IN_NO_APPS_REGISTERED);
+      [self showErrorWithMessage:errorMessage];
+    } else {
+      isOpenInMenuDisplayed_ = YES;
+    }
+  }
+}
+
+- (void)showDownloadOverlayView {
+  UIViewController* topViewController =
+      [[[UIApplication sharedApplication] keyWindow] rootViewController];
+  UIView* topView = topViewController.view;
+  overlayedView_.reset([[UIView alloc] initWithFrame:[topView bounds]]);
+  [overlayedView_ setAutoresizingMask:(UIViewAutoresizingFlexibleWidth |
+                                       UIViewAutoresizingFlexibleHeight)];
+  base::scoped_nsobject<UIView> grayBackgroundView(
+      [[UIView alloc] initWithFrame:[overlayedView_ frame]]);
+  [grayBackgroundView setBackgroundColor:[UIColor darkGrayColor]];
+  [grayBackgroundView setAlpha:kOverlayedViewBackgroundAlpha];
+  [grayBackgroundView setAutoresizingMask:(UIViewAutoresizingFlexibleWidth |
+                                           UIViewAutoresizingFlexibleHeight)];
+  [overlayedView_ addSubview:grayBackgroundView];
+
+  base::scoped_nsobject<UIActivityIndicatorView> spinner([
+      [UIActivityIndicatorView alloc]
+      initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge]);
+  [spinner setFrame:[overlayedView_ frame]];
+  [spinner setHidesWhenStopped:YES];
+  [spinner setUserInteractionEnabled:NO];
+  [spinner startAnimating];
+  [spinner setAutoresizingMask:(UIViewAutoresizingFlexibleWidth |
+                                UIViewAutoresizingFlexibleHeight)];
+  [overlayedView_ addSubview:spinner];
+
+  base::scoped_nsobject<UILabel> label([[UILabel alloc] init]);
+  [label setTextColor:[UIColor whiteColor]];
+  [label setFont:GetUIFont(FONT_HELVETICA, true, kLabelTextSize)];
+  [label setNumberOfLines:0];
+  [label setShadowColor:[UIColor blackColor]];
+  [label setShadowOffset:CGSizeMake(0.0, 1.0)];
+  [label setBackgroundColor:[UIColor clearColor]];
+  [label setText:l10n_util::GetNSString(IDS_IOS_OPEN_IN_FILE_DOWNLOAD_CANCEL)];
+  [label setLineBreakMode:NSLineBreakByWordWrapping];
+  [label setTextAlignment:NSTextAlignmentCenter];
+  CGFloat labelWidth =
+      [overlayedView_ frame].size.width * kOverlayedViewLabelWidthPercentage;
+  CGFloat originX = ([overlayedView_ frame].size.width - labelWidth) / 2;
+
+  CGFloat labelHeight =
+      [[label text] cr_boundingSizeWithSize:CGSizeMake(labelWidth, CGFLOAT_MAX)
+                                       font:[label font]]
+          .height;
+  CGFloat originY =
+      [overlayedView_ center].y - labelHeight - kOverlayedViewLabelBottomMargin;
+  [label setFrame:CGRectMake(originX, originY, labelWidth, labelHeight)];
+  [overlayedView_ addSubview:label];
+
+  base::scoped_nsobject<UITapGestureRecognizer> tapRecognizer(
+      [[UITapGestureRecognizer alloc]
+          initWithTarget:self
+                  action:@selector(handleTapOnOverlayedView:)]);
+  [tapRecognizer setDelegate:self];
+  [overlayedView_ addGestureRecognizer:tapRecognizer];
+
+  [overlayedView_ setAlpha:0.0];
+  [topView addSubview:overlayedView_];
+  UIView* overlayedView = overlayedView_.get();
+  [UIView animateWithDuration:kOverlayViewAnimationDuration
+                   animations:^{
+                     [overlayedView setAlpha:1.0];
+                   }];
+}
+
+- (UIView*)openInToolbar {
+  if (!openInToolbar_) {
+    openInToolbar_.reset([[OpenInToolbar alloc]
+        initWithTarget:self
+                action:@selector(exportFileWithOpenInMenuAnchoredAt:)]);
+  }
+  return openInToolbar_.get();
+}
+
+#pragma mark -
+#pragma mark File management
+
+- (void)removeDocumentAtPath:(NSString*)path {
+  base::ThreadRestrictions::AssertIOAllowed();
+  NSFileManager* fileManager = [NSFileManager defaultManager];
+  NSError* error = nil;
+  if (![fileManager removeItemAtPath:path error:&error]) {
+    DLOG(ERROR) << "Failed to remove file: "
+                << base::SysNSStringToUTF8([error description]);
+  }
+}
+
++ (void)removeAllStoredDocumentsAtPath:(NSString*)tempDirPath {
+  base::ThreadRestrictions::AssertIOAllowed();
+  NSFileManager* fileManager = [NSFileManager defaultManager];
+  NSError* error = nil;
+  NSArray* documentFiles =
+      [fileManager contentsOfDirectoryAtPath:tempDirPath error:&error];
+  if (!documentFiles) {
+    DLOG(ERROR) << "Failed to get content of directory at path: "
+                << base::SysNSStringToUTF8([error description]);
+    return;
+  }
+
+  for (NSString* filename in documentFiles) {
+    NSString* filePath = [tempDirPath stringByAppendingPathComponent:filename];
+    if (![fileManager removeItemAtPath:filePath error:&error]) {
+      DLOG(ERROR) << "Failed to remove file: "
+                  << base::SysNSStringToUTF8([error description]);
+    }
+  }
+}
+
++ (BOOL)createDestinationDirectoryAndRemoveObsoleteFiles {
+  base::ThreadRestrictions::AssertIOAllowed();
+  NSString* tempDirPath = [NSTemporaryDirectory()
+      stringByAppendingPathComponent:kDocumentsTempPath];
+  NSFileManager* fileManager = [NSFileManager defaultManager];
+  BOOL isDirectory;
+  NSError* error = nil;
+  if (![fileManager fileExistsAtPath:tempDirPath isDirectory:&isDirectory]) {
+    BOOL created = [fileManager createDirectoryAtPath:tempDirPath
+                          withIntermediateDirectories:YES
+                                           attributes:nil
+                                                error:&error];
+    DCHECK(created);
+    if (!created) {
+      DLOG(ERROR) << "Error creating destination dir: "
+                  << base::SysNSStringToUTF8([error description]);
+      return NO;
+    }
+  } else {
+    DCHECK(isDirectory);
+    if (!isDirectory) {
+      DLOG(ERROR) << "Destination Directory already exists and is a file.";
+      return NO;
+    }
+    // Remove all documents that might be still on temporary storage.
+    [self removeAllStoredDocumentsAtPath:(NSString*)tempDirPath];
+  }
+  return YES;
+}
+
+#pragma mark -
+#pragma mark URLFetcher delegate method
+
+- (void)urlFetchDidComplete:(const net::URLFetcher*)fetcher {
+  DCHECK(fetcher);
+  if (requestContext_.get())
+    DCHECK_CURRENTLY_ON(web::WebThread::UI);
+  base::FilePath filePath;
+  if (fetcher->GetResponseCode() == kHTTPResponseCodeSucceeded &&
+      fetcher->GetResponseAsFilePath(true, &filePath)) {
+    NSURL* fileURL =
+        [NSURL fileURLWithPath:base::SysUTF8ToNSString(filePath.value())];
+    if (downloadCanceled_) {
+      sequencedTaskRunner_->PostTask(FROM_HERE, base::BindBlock(^{
+                                       [self
+                                           removeDocumentAtPath:[fileURL path]];
+                                     }));
+    } else {
+      [self presentOpenInMenuForFileAtURL:fileURL];
+    }
+  } else if (!downloadCanceled_) {
+    if (IsIPadIdiom())
+      [self hideOpenInToolbar];
+    [self removeOverlayedView];
+    [self showErrorWithMessage:l10n_util::GetNSStringWithFixup(
+                                   IDS_IOS_OPEN_IN_FILE_DOWNLOAD_FAILED)];
+  }
+}
+
+#pragma mark -
+#pragma mark UIDocumentInteractionControllerDelegate Methods
+
+- (void)documentInteractionController:(UIDocumentInteractionController*)contr
+           didEndSendingToApplication:(NSString*)application {
+  sequencedTaskRunner_->PostTask(FROM_HERE, base::BindBlock(^{
+                                   [self
+                                       removeDocumentAtPath:[[contr URL] path]];
+                                 }));
+  if (IsIPadIdiom()) {
+    // Call the |documentInteractionControllerDidDismissOpenInMenu:| method
+    // as this is not called on the iPad after the document has been opened
+    // in another application.
+    [self documentInteractionControllerDidDismissOpenInMenu:contr];
+  }
+}
+
+- (void)documentInteractionControllerDidDismissOpenInMenu:
+    (UIDocumentInteractionController*)controller {
+  if (!IsIPadIdiom()) {
+    isOpenInMenuDisplayed_ = NO;
+    // On the iPhone the |openInToolber_| is hidden already.
+    return;
+  }
+
+  // On iPad this method is called whenever the device changes orientation,
+  // even thought the OpenIn menu is not displayed. To distinguish the cases
+  // when this method is called after the OpenIn menu is dismissed, we
+  // check the BOOL |isOpenInMenuDisplayed|.
+  if (isOpenInMenuDisplayed_) {
+    openInTimer_.reset(
+        [[NSTimer scheduledTimerWithTimeInterval:kOpenInToolbarDisplayDuration
+                                          target:self
+                                        selector:@selector(hideOpenInToolbar)
+                                        userInfo:nil
+                                         repeats:NO] retain]);
+  }
+  isOpenInMenuDisplayed_ = NO;
+}
+
+#pragma mark -
+#pragma mark UIGestureRecognizerDelegate Methods
+
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer*)gestureRecognizer {
+  if ([gestureRecognizer.view isEqual:overlayedView_])
+    return YES;
+
+  CGPoint location = [gestureRecognizer locationInView:[self openInToolbar]];
+  return ![[self openInToolbar] pointInside:location withEvent:nil];
+}
+
+#pragma mark - TestingAditions
+
+- (void)setDocumentInteractionController:
+    (UIDocumentInteractionController*)controller {
+  documentController_.reset([controller retain]);
+}
+
+- (NSString*)suggestedFilename {
+  return suggestedFilename_.get();
+}
+
+@end