Update the HTML Media Capture implementation.

ui/shell_dialogs/select_file_dialog_android.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 "select_file_dialog_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/strings/string_split.h"
 #include "base/utf_string_conversions.h"
 #include "jni/SelectFileDialog_jni.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFileChooserParams.h"
 #include "ui/android/window_android.h"
 
 namespace ui {
 
 // static
 SelectFileDialogImpl* SelectFileDialogImpl::Create(Listener* listener,
                                            ui::SelectFilePolicy* policy) {
   return new SelectFileDialogImpl(listener, policy);
 }
 
@@ skipping 29 matching lines @@
     ui::SelectFileDialog::Type type,
     const string16& title,
     const base::FilePath& default_path,
     const SelectFileDialog::FileTypeInfo* file_types,
     int file_type_index,
     const std::string& default_extension,
     gfx::NativeWindow owning_window,
     void* params) {
   JNIEnv* env = base::android::AttachCurrentThread();
 
-  std::vector<string16> accept_types =
-      *(reinterpret_cast<std::vector<string16>*>(params));
+#if defined(NEW_MEDIA_CAPTURE_IMPLEMENTATION)
+  // The first element in the pair is a list of accepted types, the second
+  // indicates whether the device's capture capabilities should be used.
+  typedef std::pair<std::vector<string16>, bool> AcceptTypes;
+  AcceptTypes accept_types = *(reinterpret_cast<AcceptTypes*>(params));
 
-  // The last string in params is expected to be the string with capture value.
+  // The latest version of the HTML Media Capture spec says the "capture"
+  // attribute should be a boolean, and implementations are supposed to infer
+  // which application to launch based on the value of the "accept" attribute.
+  // However, since we have already shipped an implementation of an earlier
+  // version of the spec in which the "capture" attribute was an enum, we need
+  // to keep compatibility for a while. We do that by creating a valid string
+  // value accepted by SelectFileDialog.java based on the contents of the
+  // "accept" attribute. This approximation is not 100% compatible with the
+  // previous behavior, as we cannot infer a value for "capture" if "accept" is
+  // set to something like "*/*" or "audio/*,video/*".
+  // FIXME: We need to phase out support for the old version of the spec at
+  // some point.

[joth, 2013/05/15 20:03:59]

We don't use FIXME in chromium. You could link to the bug.

However, as a broader point, I don't see what further phasing out is needed?
AIUI as soon as we start to define the 'NEW_MEDIA_CAPTURE_IMPLEMENTATION' we'll
already be treating any 'capture' tag in the html as a pure boolean, and
disregarding any string value that was associated with it (camera, microphone,
etc), and so from that point on we're already potentially broken pages?

Put another way, to make a more phased migration, I'd expect not to see and
compile time #if in the chromium code at all. Instead we might do something
like:
- leave the 'capture' param as a string in FileChooserParams forever.
- define a special case value, e.g. capture='true' or '*' to indicate the new
boolean param was present, otherwise it will contain the old camera or
microphone etc values as appropriate. (and empty string indicates no capture
param present at all)
- here, we'd pass through the old value direct if present, else if it's 'true'
use your logic below to try and synthesize a value.

+  bool has_capture_attribute = accept_types.second;
+  string16 normalized_capture_value;
+
+  if (has_capture_attribute && accept_types.size() == 1) {
+    if (StartsWithASCII(accept_types.front(), "image/*", false)) {
+      normalized_capture_value = "camera";
+    } else if (StartsWithASCII(accept_types.front(), "video/*", false)) {
+      normalized_capture_value = "camcorder";
+    } else if (StartsWithASCII(accept_types.front(), "audio/*", false)) {
+      normalized_capture_value = "microphone";
+    }
+  }
+
+  ScopedJavaLocalRef<jstring> capture_value =
+      base::android::ConvertUTF16ToJavaString(env, normalized_capture_value);
+#else
+  typedef std::pair<std::vector<string16>, string16> AcceptTypes;
+  AcceptTypes accept_types = *(reinterpret_cast<AcceptTypes*>(params));
+
   ScopedJavaLocalRef<jstring> capture_value =
       base::android::ConvertUTF16ToJavaString(env,
-          StringToLowerASCII(accept_types.back()));
+          StringToLowerASCII(accept_types.second));
+#endif
   base::android::CheckException(env);
-  accept_types.pop_back();
 
-  // The rest params elements are expected to be accept_types.
   ScopedJavaLocalRef<jobjectArray> accept_types_java =
-      base::android::ToJavaArrayOfStrings(env, accept_types);
+      base::android::ToJavaArrayOfStrings(env, accept_types.first);
 
   Java_SelectFileDialog_selectFile(env, java_object_.obj(),
                                    accept_types_java.obj(),
                                    capture_value.obj(),
                                    owning_window->GetJavaObject().obj());
   is_running_ = true;
 }
 
 bool SelectFileDialogImpl::RegisterSelectFileDialog(JNIEnv* env) {
   return RegisterNativesImpl(env);
@@ skipping 16 matching lines @@
   return false;
 }
 
 SelectFileDialog* CreateAndroidSelectFileDialog(
     SelectFileDialog::Listener* listener,
     SelectFilePolicy* policy) {
   return SelectFileDialogImpl::Create(listener, policy);
 }
 
 }  // namespace ui