Update the HTML Media Capture implementation.

ui/android/java/src/org/chromium/ui/SelectFileDialog.java

 // 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.
 
 package org.chromium.ui;
 
 import android.app.Activity;
 import android.content.ContentResolver;
 import android.content.Intent;
 import android.database.Cursor;
@@ skipping 16 matching lines @@
  */
 @JNINamespace("ui")
 class SelectFileDialog implements WindowAndroid.IntentCallback{
     private static final String IMAGE_TYPE = "image/";
     private static final String VIDEO_TYPE = "video/";
     private static final String AUDIO_TYPE = "audio/";
     private static final String ALL_IMAGE_TYPES = IMAGE_TYPE + "*";
     private static final String ALL_VIDEO_TYPES = VIDEO_TYPE + "*";
     private static final String ALL_AUDIO_TYPES = AUDIO_TYPE + "*";
     private static final String ANY_TYPES = "*/*";
-    private static final String CAPTURE_CAMERA = "camera";
-    private static final String CAPTURE_CAMCORDER = "camcorder";
-    private static final String CAPTURE_MICROPHONE = "microphone";
-    private static final String CAPTURE_FILESYSTEM = "filesystem";
     private static final String CAPTURE_IMAGE_DIRECTORY = "browser-photos";
 
     private final int mNativeSelectFileDialog;
     private List<String> mFileTypes;
-    private String mCapture;  // May be null if no capture parameter was set.
+    private boolean mCapture;
     private Uri mCameraOutputUri;
 
     private SelectFileDialog(int nativeSelectFileDialog) {
         mNativeSelectFileDialog = nativeSelectFileDialog;
     }
 
     /**
      * Creates and starts an intent based on the passed fileTypes and capture value.
      * @param fileTypes MIME types requested (i.e. "image/*")
      * @param capture The capture value as described in http://www.w3.org/TR/html-media-capture/
      * @param window The WindowAndroid that can show intents
      */
     @CalledByNative
-    private void selectFile(String[] fileTypes, String capture, WindowAndroid window) {
+    private void selectFile(String[] fileTypes, boolean capture, WindowAndroid window) {
         mFileTypes = new ArrayList<String>(Arrays.asList(fileTypes));
         mCapture = capture;
 
         Intent chooser = new Intent(Intent.ACTION_CHOOSER);
         Intent camera = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
         mCameraOutputUri = Uri.fromFile(getFileForImageCapture());
         camera.putExtra(MediaStore.EXTRA_OUTPUT, mCameraOutputUri);
         Intent camcorder = new Intent(MediaStore.ACTION_VIDEO_CAPTURE);
         Intent soundRecorder = new Intent(
                 MediaStore.Audio.Media.RECORD_SOUND_ACTION);
         String lowMemoryError = window.getContext().getString(R.string.low_memory_error);
 
-        // Quick check - if a capture parameter other than filesystem (the default) is specified we
-        // should just launch the appropriate intent. Otherwise build up a chooser based on the
-        // accept type and then display that to the user.
+        // Quick check - if the |capture| parameter is set and |fileTypes| has the appropriate MIME
+        // type, we should just launch the appropriate intent. Otherwise build up a chooser based on
+        // the accept type and then display that to the user.
         if (captureCamera()) {
             if (window.showIntent(camera, this, lowMemoryError)) return;
         } else if (captureCamcorder()) {
             if (window.showIntent(camcorder, this, lowMemoryError)) return;
         } else if (captureMicrophone()) {
             if (window.showIntent(soundRecorder, this, lowMemoryError)) return;
         }
 
         Intent getContentIntent = new Intent(Intent.ACTION_GET_CONTENT);
         getContentIntent.addCategory(Intent.CATEGORY_OPENABLE);
         ArrayList<Intent> extraIntents = new ArrayList<Intent>();
         if (!noSpecificType()) {
             // Create a chooser based on the accept type that was specified in the webpage. Note
             // that if the web page specified multiple accept types, we will have built a generic
             // chooser above.
             if (shouldShowImageTypes()) {
                 extraIntents.add(camera);
                 getContentIntent.setType("image/*");

[joth, 2013/07/04 16:55:22]

(patch creep) this could be ALL_IMAGE_TYPES etc here

             } else if (shouldShowVideoTypes()) {
                 extraIntents.add(camcorder);
                 getContentIntent.setType("video/*");
             } else if (shouldShowAudioTypes()) {
                 extraIntents.add(soundRecorder);
                 getContentIntent.setType("audio/*");
             }
         }
 
         if (extraIntents.isEmpty()) {
             // We couldn't resolve an accept type, so fallback to a generic chooser.
             getContentIntent.setType("*/*");

[joth, 2013/07/04 16:55:22]

ALL_TYPES

             extraIntents.add(camera);
             extraIntents.add(camcorder);
             extraIntents.add(soundRecorder);
         }
 
         chooser.putExtra(Intent.EXTRA_INITIAL_INTENTS,
                 extraIntents.toArray(new Intent[] { }));
 
         chooser.putExtra(Intent.EXTRA_INTENT, getContentIntent);
 
@@ skipping 93 matching lines @@
     }
 
     private boolean shouldShowVideoTypes() {
         return shouldShowTypes(ALL_VIDEO_TYPES, VIDEO_TYPE);
     }
 
     private boolean shouldShowAudioTypes() {
         return shouldShowTypes(ALL_AUDIO_TYPES, AUDIO_TYPE);
     }
 
+    private boolean acceptsSpecificType(String type) {
+        return mFileTypes.size() == 1 && mFileTypes.at(0).equals(type);
+    }
+
     private boolean captureCamera() {
-        return shouldShowImageTypes() && mCapture != null && mCapture.startsWith(CAPTURE_CAMERA);
+        return mCapture && acceptsSpecificType(ALL_IMAGE_TYPES);
     }
 
     private boolean captureCamcorder() {
-        return shouldShowVideoTypes() && mCapture != null &&
-                mCapture.startsWith(CAPTURE_CAMCORDER);
+        return mCapture && acceptsSpecificType(ALL_VIDEO_TYPES);
     }
 
     private boolean captureMicrophone() {
-        return shouldShowAudioTypes() && mCapture != null &&
-                mCapture.startsWith(CAPTURE_MICROPHONE);
-    }
-
-    private boolean captureFilesystem() {
-        return mCapture != null && mCapture.startsWith(CAPTURE_FILESYSTEM);
+        return mCapture && acceptsSpecificType(ALL_AUDIO_TYPES);
     }
 
     private boolean acceptSpecificType(String accept) {
         for (String type : mFileTypes) {
             if (type.startsWith(accept)) {
                 return true;
             }
         }
         return false;
     }
 
     @CalledByNative
     private static SelectFileDialog create(int nativeSelectFileDialog) {
         return new SelectFileDialog(nativeSelectFileDialog);
     }
 
     private native void nativeOnFileSelected(int nativeSelectFileDialogImpl,
             String filePath);
     private native void nativeOnFileNotSelected(int nativeSelectFileDialogImpl);
 }