Use mime type for image extension

ios/chrome/browser/ui/browser_view_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/browser_view_controller.h"
 
 #import <AssetsLibrary/AssetsLibrary.h>
 #import <MobileCoreServices/MobileCoreServices.h>
 #import <PassKit/PassKit.h>
 #import <Photos/Photos.h>
 #import <QuartzCore/QuartzCore.h>
 
 #include <stdint.h>
 #include <cmath>
 #include <memory>
 
 #include "base/base64.h"
 #include "base/command_line.h"
+#include "base/files/file_path.h"
 #include "base/format_macros.h"
 #include "base/i18n/rtl.h"
 #include "base/ios/block_types.h"
 #include "base/ios/ios_util.h"
 #include "base/ios/weak_nsobject.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/objc_property_releaser.h"
@@ skipping 146 matching lines @@
 #include "ios/web/public/url_scheme_util.h"
 #include "ios/web/public/web_client.h"
 #import "ios/web/public/web_state/context_menu_params.h"
 #import "ios/web/public/web_state/crw_web_view_proxy.h"
 #import "ios/web/public/web_state/ui/crw_native_content_provider.h"
 #include "ios/web/public/web_state/web_state.h"
 #import "ios/web/public/web_state/web_state_delegate_bridge.h"
 #include "ios/web/public/web_thread.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #import "net/base/mac/url_conversions.h"
+#include "net/base/mime_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/ssl/ssl_info.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/google_toolbox_for_mac/src/iPhone/GTMUIImage+Resize.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 #include "ui/base/page_transition_types.h"
 #include "url/gurl.h"
 
 using base::UserMetricsAction;
@@ skipping 486 matching lines @@
 // Dismisses previous alert if it has not been dismissed yet.
 - (void)showErrorAlertWithStringTitle:(NSString*)title
                               message:(NSString*)message;
 // Shows a self-dismissing snackbar displaying |message|.
 - (void)showSnackbar:(NSString*)message;
 // Induces an intentional crash in the browser process.
 - (void)induceBrowserCrash;
 // Returns Tab that corresponds to the given |webState|.
 - (Tab*)tabForWebState:(web::WebState*)webState;
 // Saves the image or display error message, based on privacy settings.
-- (void)managePermissionAndSaveImage:(NSData*)data;
+- (void)managePermissionAndSaveImage:(NSData*)data
+                   withFileExtension:(NSString*)fileExtension;
 // Saves the image. In order to keep the metadata of the image, the image is
 // saved as a temporary file on disk then saved in photos.
 // This should be called on FILE thread.
-- (void)saveImage:(NSData*)data;
+- (void)saveImage:(NSData*)data withFileExtension:(NSString*)fileExtension;
 // Called when Chrome has been denied access to the photos or videos and the
 // user can change it.
 // Shows a privacy alert on the main queue, allowing the user to go to Chrome's
 // settings. Dismiss previous alert if it has not been dismissed yet.
 - (void)displayImageErrorAlertWithSettingsOnMainQueue;
 // Shows a privacy alert allowing the user to go to Chrome's settings. Dismiss
 // previous alert if it has not been dismissed yet.
 - (void)displayImageErrorAlertWithSettings:(NSURL*)settingURL;
 // Called when Chrome has been denied access to the photos or videos and the
 // user cannot change it.
@@ skipping 2387 matching lines @@
       search_args, templateUrlService->search_terms_data(), &post_content));
   [self addSelectedTabWithURL:result
                      postData:&post_content
                    transition:ui::PAGE_TRANSITION_TYPED];
 }
 
 - (void)saveImageAtURL:(const GURL&)url
               referrer:(const web::Referrer&)referrer {
   DCHECK(url.is_valid());
 
-  web::ImageFetchedCallback callback =
-      ^(const GURL& original_url, int response_code, NSData* data) {
-        DCHECK(data);
+  web::ImageFetchedCallbackWithMime callback = ^(
+      const GURL& original_url, int response_code, const std::string& mime_type,
+      NSData* data) {
+    DCHECK(data);
 
-        [self managePermissionAndSaveImage:data];
-      };
-  _imageFetcher->StartDownload(
+    base::FilePath::StringType extension;
+
+    bool extensionSuccess =
+        net::GetPreferredExtensionForMimeType(mime_type, &extension);
+    if (!extensionSuccess || extension.length() == 0) {
+      extension = "png";
+    }
+    NSString* fileExtension =
+        [@"." stringByAppendingString:base::SysUTF8ToNSString(extension)];
+    [self managePermissionAndSaveImage:data withFileExtension:fileExtension];
+  };
+  _imageFetcher->StartDownloadWithMime(
       url, callback, web::ReferrerHeaderValueForNavigation(url, referrer),
       web::PolicyForNavigation(url, referrer));
 }
 
-- (void)managePermissionAndSaveImage:(NSData*)data {
+- (void)managePermissionAndSaveImage:(NSData*)data
+                   withFileExtension:(NSString*)fileExtension {
   switch ([PHPhotoLibrary authorizationStatus]) {
     // User was never asked for permission to access photos.
     case PHAuthorizationStatusNotDetermined:
       [PHPhotoLibrary requestAuthorization:^(PHAuthorizationStatus status) {
         // Call -saveImage again to check if chrome needs to display an error or
         // saves the image.
         if (status != PHAuthorizationStatusNotDetermined)
-          [self managePermissionAndSaveImage:data];
+          [self managePermissionAndSaveImage:data
+                           withFileExtension:fileExtension];
       }];
       break;
 
     // The application doesn't have permission to access photo and the user
     // cannot grant it.
     case PHAuthorizationStatusRestricted:
       [self displayPrivacyErrorAlertOnMainQueue:
                 l10n_util::GetNSString(
                     IDS_IOS_SAVE_IMAGE_RESTRICTED_PRIVACY_ALERT_MESSAGE)];
       break;
 
     // The application doesn't have permission to access photo and the user
     // can grant it.
     case PHAuthorizationStatusDenied:
       [self displayImageErrorAlertWithSettingsOnMainQueue];
       break;
 
     // The application has permission to access the photos.
     default: {
-      web::WebThread::PostTask(web::WebThread::FILE, FROM_HERE,
-                               base::BindBlock(^{
-                                 [self saveImage:data];
-                               }));
+      web::WebThread::PostTask(
+          web::WebThread::FILE, FROM_HERE, base::BindBlock(^{
+            [self saveImage:data withFileExtension:fileExtension];
+          }));
       break;
     }
   }
 }
 
-- (void)saveImage:(NSData*)data {
+- (void)saveImage:(NSData*)data withFileExtension:(NSString*)fileExtension {
   NSString* fileName = [[[NSProcessInfo processInfo] globallyUniqueString]
-      stringByAppendingString:@".png"];
+      stringByAppendingString:fileExtension];
   NSURL* fileURL =
       [NSURL fileURLWithPath:[NSTemporaryDirectory()
                                  stringByAppendingPathComponent:fileName]];
   NSError* error = nil;
   [data writeToURL:fileURL options:NSDataWritingAtomic error:&error];
 
   // Error while writing the image to disk.
   if (error) {
     NSString* errorMessage = [NSString
         stringWithFormat:@"%@ (%@ %" PRIdNS ")", [error localizedDescription],
@@ skipping 1949 matching lines @@
 
 - (UIView*)voiceSearchButton {
   return _voiceSearchButton;
 }
 
 - (id<LogoAnimationControllerOwner>)logoAnimationControllerOwner {
   return [self currentLogoAnimationControllerOwner];
 }
 
 @end