/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

* License, v. 2.0. If a copy of the MPL was not distributed with this

* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/dom/HTMLInputElement.h"

#include "mozilla/ArrayUtils.h"

#include "mozilla/AsyncEventDispatcher.h"

#include "mozilla/DebugOnly.h"

#include "mozilla/dom/Date.h"

#include "mozilla/dom/Directory.h"

#include "mozilla/dom/FileSystemUtils.h"

#include "mozilla/dom/OSFileSystem.h"

#include "nsAttrValueInlines.h"

#include "nsCRTGlue.h"

#include "nsIDOMHTMLInputElement.h"

#include "nsITextControlElement.h"

#include "nsIDOMNSEditableElement.h"

#include "nsIRadioVisitor.h"

#include "nsIPhonetic.h"

#include "mozilla/Telemetry.h"

#include "nsIControllers.h"

#include "nsIStringBundle.h"

#include "nsFocusManager.h"

#include "nsColorControlFrame.h"

#include "nsNumberControlFrame.h"

#include "nsPIDOMWindow.h"

#include "nsRepeatService.h"

#include "nsContentCID.h"

#include "nsIComponentManager.h"

#include "nsIDOMHTMLFormElement.h"

#include "mozilla/dom/ProgressEvent.h"

#include "nsGkAtoms.h"

#include "nsStyleConsts.h"

#include "nsPresContext.h"

#include "nsMappedAttributes.h"

#include "nsIFormControl.h"

#include "nsIForm.h"

#include "nsFormSubmission.h"

#include "nsFormSubmissionConstants.h"

#include "nsIDocument.h"

#include "nsIPresShell.h"

#include "nsIFormControlFrame.h"

#include "nsITextControlFrame.h"

#include "nsIFrame.h"

#include "nsRangeFrame.h"

#include "nsIServiceManager.h"

#include "nsError.h"

#include "nsIEditor.h"

#include "nsIIOService.h"

#include "nsDocument.h"

#include "nsAttrValueOrString.h"

#include "nsPresState.h"

#include "nsIDOMEvent.h"

#include "nsIDOMNodeList.h"

#include "nsIDOMHTMLCollection.h"

#include "nsLinebreakConverter.h" //to strip out carriage returns

#include "nsReadableUtils.h"

#include "nsUnicharUtils.h"

#include "nsLayoutUtils.h"

#include "nsVariant.h"

#include "nsIDOMMutationEvent.h"

#include "mozilla/ContentEvents.h"

#include "mozilla/EventDispatcher.h"

#include "mozilla/EventStates.h"

#include "mozilla/InternalMutationEvent.h"

#include "mozilla/TextEvents.h"

#include "mozilla/TouchEvents.h"

#include "nsRuleData.h"

#include <algorithm>

// input type=radio

#include "nsIRadioGroupContainer.h"

// input type=file

#include "mozilla/dom/File.h"

#include "mozilla/dom/FileList.h"

#include "nsIFile.h"

#include "nsNetCID.h"

#include "nsNetUtil.h"

#include "nsDirectoryServiceDefs.h"

#include "nsIContentPrefService.h"

#include "nsIMIMEService.h"

#include "nsIObserverService.h"

#include "nsIPopupWindowManager.h"

#include "nsGlobalWindow.h"

// input type=image

#include "nsImageLoadingContent.h"

#include "imgRequestProxy.h"

#include "mozAutoDocUpdate.h"

#include "nsContentCreatorFunctions.h"

#include "nsContentUtils.h"

#include "mozilla/dom/DirectionalityUtils.h"

#include "nsRadioVisitor.h"

#include "nsTextEditorState.h"

#include "mozilla/LookAndFeel.h"

#include "mozilla/Preferences.h"

#include "mozilla/MathAlgorithms.h"

#include "nsIIDNService.h"

#include <limits>

#include "nsIColorPicker.h"

#include "nsIStringEnumerator.h"

#include "HTMLSplitOnSpacesTokenizer.h"

#include "nsIController.h"

#include "nsIMIMEInfo.h"

#include "nsFrameSelection.h"

// input type=date

#include "js/Date.h"

#include "nsIDatePicker.h" // TenFourFox issue 405

// input type=time

#include "nsITimePicker.h" // TenFourFox issue 405

NS_IMPL_NS_NEW_HTML_ELEMENT_CHECK_PARSER(Input)

// XXX align=left, hspace, vspace, border? other nav4 attrs

static NS_DEFINE_CID(kXULControllersCID, NS_XULCONTROLLERS_CID);

// This must come outside of any namespace, or else it won't overload with the

// double based version in nsMathUtils.h

inline mozilla::Decimal

NS_floorModulo(mozilla::Decimal x, mozilla::Decimal y)

{

return (x - y * (x / y).floor());

}

namespace mozilla {

namespace dom {

// First bits are needed for the control type.

#define NS_OUTER_ACTIVATE_EVENT (1 << 9)

#define NS_ORIGINAL_CHECKED_VALUE (1 << 10)

#define NS_NO_CONTENT_DISPATCH (1 << 11)

#define NS_ORIGINAL_INDETERMINATE_VALUE (1 << 12)

#define NS_CONTROL_TYPE(bits) ((bits) & ~( \

NS_OUTER_ACTIVATE_EVENT | NS_ORIGINAL_CHECKED_VALUE | NS_NO_CONTENT_DISPATCH | \

NS_ORIGINAL_INDETERMINATE_VALUE))

// whether textfields should be selected once focused:

// -1: no, 1: yes, 0: uninitialized

static int32_t gSelectTextFieldOnFocus;

UploadLastDir* HTMLInputElement::gUploadLastDir;

static const nsAttrValue::EnumTable kInputTypeTable[] = {

{ "button", NS_FORM_INPUT_BUTTON },

{ "checkbox", NS_FORM_INPUT_CHECKBOX },

{ "color", NS_FORM_INPUT_COLOR },

{ "date", NS_FORM_INPUT_DATE },

{ "email", NS_FORM_INPUT_EMAIL },

{ "file", NS_FORM_INPUT_FILE },

{ "hidden", NS_FORM_INPUT_HIDDEN },

{ "reset", NS_FORM_INPUT_RESET },

{ "image", NS_FORM_INPUT_IMAGE },

{ "number", NS_FORM_INPUT_NUMBER },

{ "password", NS_FORM_INPUT_PASSWORD },

{ "radio", NS_FORM_INPUT_RADIO },

{ "range", NS_FORM_INPUT_RANGE },

{ "search", NS_FORM_INPUT_SEARCH },

{ "submit", NS_FORM_INPUT_SUBMIT },

{ "tel", NS_FORM_INPUT_TEL },

{ "text", NS_FORM_INPUT_TEXT },

{ "time", NS_FORM_INPUT_TIME },

{ "url", NS_FORM_INPUT_URL },

{ 0 }

};

// Default type is 'text'.

static const nsAttrValue::EnumTable* kInputDefaultType = &kInputTypeTable[16];

static const uint8_t NS_INPUT_INPUTMODE_AUTO = 0;

static const uint8_t NS_INPUT_INPUTMODE_NUMERIC = 1;

static const uint8_t NS_INPUT_INPUTMODE_DIGIT = 2;

static const uint8_t NS_INPUT_INPUTMODE_UPPERCASE = 3;

static const uint8_t NS_INPUT_INPUTMODE_LOWERCASE = 4;

static const uint8_t NS_INPUT_INPUTMODE_TITLECASE = 5;

static const uint8_t NS_INPUT_INPUTMODE_AUTOCAPITALIZED = 6;

static const nsAttrValue::EnumTable kInputInputmodeTable[] = {

{ "auto", NS_INPUT_INPUTMODE_AUTO },

{ "numeric", NS_INPUT_INPUTMODE_NUMERIC },

{ "digit", NS_INPUT_INPUTMODE_DIGIT },

{ "uppercase", NS_INPUT_INPUTMODE_UPPERCASE },

{ "lowercase", NS_INPUT_INPUTMODE_LOWERCASE },

{ "titlecase", NS_INPUT_INPUTMODE_TITLECASE },

{ "autocapitalized", NS_INPUT_INPUTMODE_AUTOCAPITALIZED },

{ 0 }

};

// Default inputmode value is "auto".

static const nsAttrValue::EnumTable* kInputDefaultInputmode = &kInputInputmodeTable[0];

const Decimal HTMLInputElement::kStepScaleFactorDate = Decimal(86400000);

const Decimal HTMLInputElement::kStepScaleFactorNumberRange = Decimal(1);

const Decimal HTMLInputElement::kStepScaleFactorTime = Decimal(1000);

const Decimal HTMLInputElement::kDefaultStepBase = Decimal(0);

const Decimal HTMLInputElement::kDefaultStep = Decimal(1);

const Decimal HTMLInputElement::kDefaultStepTime = Decimal(60);

const Decimal HTMLInputElement::kStepAny = Decimal(0);

#define NS_INPUT_ELEMENT_STATE_IID \

{ /* dc3b3d14-23e2-4479-b513-7b369343e3a0 */ \

0xdc3b3d14, \

0x23e2, \

0x4479, \

{0xb5, 0x13, 0x7b, 0x36, 0x93, 0x43, 0xe3, 0xa0} \

}

#define PROGRESS_STR "progress"

static const uint32_t kProgressEventInterval = 50; // ms

// Increase performance of checking for enabled types of input elements.

// TenFourFox issue 405

static bool sDOMInputPrefsCacheInitialized = false;

static bool sDOMInputEnableDate = false;

static bool sDOMInputEnableTime = false;

static bool sDOMInputEnableColor = false;

static bool sDOMInputEnableNumber = false;

static void InitializeDOMInputPrefCache() {

if (MOZ_UNLIKELY(sDOMInputPrefsCacheInitialized)) return;

Preferences::AddBoolVarCache(&sDOMInputEnableDate, "tenfourfox.dom.forms.date");

Preferences::AddBoolVarCache(&sDOMInputEnableTime, "tenfourfox.dom.forms.time");

// Mozilla implementations that existed prior

Preferences::AddBoolVarCache(&sDOMInputEnableColor, "dom.forms.color");

Preferences::AddBoolVarCache(&sDOMInputEnableNumber, "dom.forms.number");

sDOMInputPrefsCacheInitialized = true;

}

#define ENABLED(x) static inline bool Input ## x ## Enabled() { \

if (MOZ_UNLIKELY(!sDOMInputPrefsCacheInitialized)) InitializeDOMInputPrefCache(); \

return sDOMInputEnable ## x ; \

}

ENABLED(Date)

ENABLED(Time)

ENABLED(Color)

ENABLED(Number)

#undef ENABLED

class HTMLInputElementState final : public nsISupports

{

public:

NS_DECLARE_STATIC_IID_ACCESSOR(NS_INPUT_ELEMENT_STATE_IID)

NS_DECL_ISUPPORTS

bool IsCheckedSet()

{

return mCheckedSet;

}

bool GetChecked()

{

return mChecked;

}

void SetChecked(bool aChecked)

{

mChecked = aChecked;

mCheckedSet = true;

}

const nsString& GetValue()

{

return mValue;

}

void SetValue(const nsAString& aValue)

{

mValue = aValue;

}

const nsTArray<RefPtr<BlobImpl>>& GetBlobImpls()

{

return mBlobImpls;

}

void SetBlobImpls(const nsTArray<RefPtr<File>>& aFile)

{

mBlobImpls.Clear();

for (uint32_t i = 0, len = aFile.Length(); i < len; ++i) {

mBlobImpls.AppendElement(aFile[i]->Impl());

}

}

HTMLInputElementState()

: mValue()

, mChecked(false)

, mCheckedSet(false)

{}

protected:

~HTMLInputElementState() {}

nsString mValue;

nsTArray<RefPtr<BlobImpl>> mBlobImpls;

bool mChecked;

bool mCheckedSet;

};

NS_DEFINE_STATIC_IID_ACCESSOR(HTMLInputElementState, NS_INPUT_ELEMENT_STATE_IID)

NS_IMPL_ISUPPORTS(HTMLInputElementState, HTMLInputElementState)

HTMLInputElement::nsFilePickerShownCallback::nsFilePickerShownCallback(

HTMLInputElement* aInput, nsIFilePicker* aFilePicker)

: mFilePicker(aFilePicker)

, mInput(aInput)

{

}

NS_IMPL_ISUPPORTS(UploadLastDir::ContentPrefCallback, nsIContentPrefCallback2)

NS_IMETHODIMP

UploadLastDir::ContentPrefCallback::HandleCompletion(uint16_t aReason)

{

nsCOMPtr<nsIFile> localFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID);

NS_ENSURE_STATE(localFile);

if (aReason == nsIContentPrefCallback2::COMPLETE_ERROR ||

!mResult) {

// Default to "desktop" directory for each platform

nsCOMPtr<nsIFile> homeDir;

NS_GetSpecialDirectory(NS_OS_DESKTOP_DIR, getter_AddRefs(homeDir));

localFile = do_QueryInterface(homeDir);

} else {

nsAutoString prefStr;

nsCOMPtr<nsIVariant> pref;

mResult->GetValue(getter_AddRefs(pref));

pref->GetAsAString(prefStr);

localFile->InitWithPath(prefStr);

}

mFilePicker->SetDisplayDirectory(localFile);

mFilePicker->Open(mFpCallback);

return NS_OK;

}

NS_IMETHODIMP

UploadLastDir::ContentPrefCallback::HandleResult(nsIContentPref* pref)

{

mResult = pref;

return NS_OK;

}

NS_IMETHODIMP

UploadLastDir::ContentPrefCallback::HandleError(nsresult error)

{

// HandleCompletion is always called (even with HandleError was called),

// so we don't need to do anything special here.

return NS_OK;

}

namespace {

/**

* This may return nullptr if aDomFile's implementation of

* File::mozFullPathInternal does not successfully return a non-empty

* string that is a valid path. This can happen on Firefox OS, for example,

* where the file picker can create Blobs.

*/

static already_AddRefed<nsIFile>

DOMFileToLocalFile(File* aDomFile)

{

nsString path;

ErrorResult rv;

aDomFile->GetMozFullPathInternal(path, rv);

if (rv.Failed() || path.IsEmpty()) {

rv.SuppressException();

return nullptr;

}

nsCOMPtr<nsIFile> localFile;

rv = NS_NewNativeLocalFile(NS_ConvertUTF16toUTF8(path), true,

getter_AddRefs(localFile));

if (NS_WARN_IF(rv.Failed())) {

rv.SuppressException();

return nullptr;

}

return localFile.forget();

}

} // namespace

NS_IMETHODIMP

HTMLInputElement::nsFilePickerShownCallback::Done(int16_t aResult)

{

mInput->PickerClosed();

if (aResult == nsIFilePicker::returnCancel) {

return NS_OK;

}

int16_t mode;

mFilePicker->GetMode(&mode);

// Collect new selected filenames

nsTArray<RefPtr<File>> newFiles;

if (mode == static_cast<int16_t>(nsIFilePicker::modeOpenMultiple)) {

nsCOMPtr<nsISimpleEnumerator> iter;

nsresult rv = mFilePicker->GetDomfiles(getter_AddRefs(iter));

NS_ENSURE_SUCCESS(rv, rv);

if (!iter) {

return NS_OK;

}

nsCOMPtr<nsISupports> tmp;

bool hasMore = true;

while (NS_SUCCEEDED(iter->HasMoreElements(&hasMore)) && hasMore) {

iter->GetNext(getter_AddRefs(tmp));

nsCOMPtr<nsIDOMBlob> domBlob = do_QueryInterface(tmp);

MOZ_ASSERT(domBlob,

"Null file object from FilePicker's file enumerator?");

if (domBlob) {

newFiles.AppendElement(static_cast<File*>(domBlob.get()));

}

}

} else {

MOZ_ASSERT(mode == static_cast<int16_t>(nsIFilePicker::modeOpen) ||

mode == static_cast<int16_t>(nsIFilePicker::modeGetFolder));

nsCOMPtr<nsISupports> tmp;

nsresult rv = mFilePicker->GetDomfile(getter_AddRefs(tmp));

NS_ENSURE_SUCCESS(rv, rv);

nsCOMPtr<nsIDOMBlob> blob = do_QueryInterface(tmp);

if (blob) {

RefPtr<File> file = static_cast<Blob*>(blob.get())->ToFile();

newFiles.AppendElement(file);

}

}

if (newFiles.IsEmpty()) {

return NS_OK;

}

// Store the last used directory using the content pref service:

nsCOMPtr<nsIFile> file = DOMFileToLocalFile(newFiles[0]);

if (file) {

nsCOMPtr<nsIFile> lastUsedDir;

file->GetParent(getter_AddRefs(lastUsedDir));

HTMLInputElement::gUploadLastDir->StoreLastUsedDirectory(

mInput->OwnerDoc(), lastUsedDir);

}

// The text control frame (if there is one) isn't going to send a change

// event because it will think this is done by a script.

// So, we can safely send one by ourself.

mInput->SetFiles(newFiles, true);

return nsContentUtils::DispatchTrustedEvent(mInput->OwnerDoc(),

static_cast<nsIDOMHTMLInputElement*>(mInput.get()),

NS_LITERAL_STRING("change"), true,

false);

}

NS_IMPL_ISUPPORTS(HTMLInputElement::nsFilePickerShownCallback,

nsIFilePickerShownCallback)

class nsColorPickerShownCallback final

: public nsIColorPickerShownCallback

{

~nsColorPickerShownCallback() {}

public:

nsColorPickerShownCallback(HTMLInputElement* aInput,

nsIColorPicker* aColorPicker)

: mInput(aInput)

, mColorPicker(aColorPicker)

, mValueChanged(false)

{}

NS_DECL_ISUPPORTS

NS_IMETHOD Update(const nsAString& aColor) override;

NS_IMETHOD Done(const nsAString& aColor) override;

private:

/**

* Updates the internals of the object using aColor as the new value.

* If aTrustedUpdate is true, it will consider that aColor is a new value.

* Otherwise, it will check that aColor is different from the current value.

*/

nsresult UpdateInternal(const nsAString& aColor, bool aTrustedUpdate);

RefPtr<HTMLInputElement> mInput;

nsCOMPtr<nsIColorPicker> mColorPicker;

bool mValueChanged;

};

nsresult

nsColorPickerShownCallback::UpdateInternal(const nsAString& aColor,

bool aTrustedUpdate)

{

bool valueChanged = false;

nsAutoString oldValue;

if (aTrustedUpdate) {

valueChanged = true;

} else {

mInput->GetValue(oldValue);

}

mInput->SetValue(aColor);

if (!aTrustedUpdate) {

nsAutoString newValue;

mInput->GetValue(newValue);

if (!oldValue.Equals(newValue)) {

valueChanged = true;

}

}

if (valueChanged) {

mValueChanged = true;

return nsContentUtils::DispatchTrustedEvent(mInput->OwnerDoc(),

static_cast<nsIDOMHTMLInputElement*>(mInput.get()),

NS_LITERAL_STRING("input"), true,

false);

}

return NS_OK;

}

NS_IMETHODIMP

nsColorPickerShownCallback::Update(const nsAString& aColor)

{

return UpdateInternal(aColor, true);

}

NS_IMETHODIMP

nsColorPickerShownCallback::Done(const nsAString& aColor)

{

/**

* When Done() is called, we might be at the end of a serie of Update() calls

* in which case mValueChanged is set to true and a change event will have to

* be fired but we might also be in a one shot Done() call situation in which

* case we should fire a change event iif the value actually changed.

* UpdateInternal(bool) is taking care of that logic for us.

*/

nsresult rv = NS_OK;

mInput->PickerClosed();

if (!aColor.IsEmpty()) {

UpdateInternal(aColor, false);

}

if (mValueChanged) {

rv = nsContentUtils::DispatchTrustedEvent(mInput->OwnerDoc(),

static_cast<nsIDOMHTMLInputElement*>(mInput.get()),

NS_LITERAL_STRING("change"), true,

false);

}

return rv;

}

NS_IMPL_ISUPPORTS(nsColorPickerShownCallback, nsIColorPickerShownCallback)

HTMLInputElement::nsDatePickerShownCallback::nsDatePickerShownCallback(

HTMLInputElement* aInput, nsIDatePicker* aDatePicker)

: mDatePicker(aDatePicker)

, mInput(aInput)

{

}

NS_IMETHODIMP

HTMLInputElement::nsDatePickerShownCallback::Done(int16_t aResult)

{

mInput->PickerClosed();

if (aResult == nsIDatePicker::returnCancel) {

return NS_OK;

}

nsAutoString date;

nsresult rv = mDatePicker->GetSelectedDate(date);

NS_ENSURE_SUCCESS(rv, rv);

mInput->SetValue(date); // set value

// The text control frame (if there is one) isn't going to send a change

// event because it will think this is done by a script.

// So, we can safely send one by ourself.

// Send both input and change events at the same time, since from the

// browser's perspective that's exactly what's happening.

rv = nsContentUtils::DispatchTrustedEvent(mInput->OwnerDoc(),

static_cast<nsIDOMHTMLInputElement*>(mInput.get()),

NS_LITERAL_STRING("input"), true,

false);

NS_ENSURE_SUCCESS(rv, rv);

return nsContentUtils::DispatchTrustedEvent(mInput->OwnerDoc(),

static_cast<nsIDOMHTMLInputElement*>(mInput.get()),

NS_LITERAL_STRING("change"), true,

false);

}

NS_IMPL_ISUPPORTS(HTMLInputElement::nsDatePickerShownCallback,

nsIDatePickerShownCallback)

HTMLInputElement::nsTimePickerShownCallback::nsTimePickerShownCallback(

HTMLInputElement* aInput, nsITimePicker* aTimePicker)

: mTimePicker(aTimePicker)

, mInput(aInput)

{

}

NS_IMETHODIMP

HTMLInputElement::nsTimePickerShownCallback::Done(int16_t aResult)

{

mInput->PickerClosed();

if (aResult == nsITimePicker::returnCancel) {

return NS_OK;

}

// The result is automatically truncated by the NSDateFormatter;

// we don't have to post-process it here.

nsAutoString time;

nsresult rv = mTimePicker->GetSelectedTime(time);

NS_ENSURE_SUCCESS(rv, rv);

mInput->SetValue(time); // set value

// The text control frame (if there is one) isn't going to send a change

// event because it will think this is done by a script.

// So, we can safely send one by ourself.

// Send both input and change events as above.

rv = nsContentUtils::DispatchTrustedEvent(mInput->OwnerDoc(),

static_cast<nsIDOMHTMLInputElement*>(mInput.get()),

NS_LITERAL_STRING("input"), true,

false);

NS_ENSURE_SUCCESS(rv, rv);

return nsContentUtils::DispatchTrustedEvent(mInput->OwnerDoc(),

static_cast<nsIDOMHTMLInputElement*>(mInput.get()),

NS_LITERAL_STRING("change"), true,

false);

}

NS_IMPL_ISUPPORTS(HTMLInputElement::nsTimePickerShownCallback,

nsITimePickerShownCallback)

bool

HTMLInputElement::IsPopupBlocked() const

{

nsCOMPtr<nsPIDOMWindow> win = OwnerDoc()->GetWindow();

MOZ_ASSERT(win, "window should not be null");

if (!win) {

return true;

}

// Check if page is allowed to open the popup

if (win->GetPopupControlState() <= openControlled) {

return false;

}

nsCOMPtr<nsIPopupWindowManager> pm = do_GetService(NS_POPUPWINDOWMANAGER_CONTRACTID);

if (!pm) {

return true;

}

uint32_t permission;

pm->TestPermission(OwnerDoc()->NodePrincipal(), &permission);

return permission == nsIPopupWindowManager::DENY_POPUP;

}

/* Time and date picker implementations from TenFourFox issue 405. */

static bool

IsTimeInRightFormat(nsAutoString &aTime, double aStep)

{

// Avoid exposing web-defined time strings to OS X, since I have

// no idea what crap lurks in there. Check that there are digits

// and : in the right place. We assume NSDateFormatter can at least

// reject values that are out of range.

// XXX:

// Since the step determines the template that NSDateFormatter uses,

// an eight character (HH:MM:SS) time with step >= 60 should fail,

// and a five character (HH:MM) time with step < 60 should too, or the

// formatter may choose bizarre times. This is probably not websafe

// but that's too bad. As a real world example, one of the MDN time

// examples uses "9:00" as the minimum time. This fails this test, but

// the comments in ParseTime() indicates that HH:MM is the only valid

// format, not H:MM. Furthermore, the real Firefox 61 also doesn't

// accept it as a minimum time, so we are consistent with recent builds.

// The spec allows HH:MM:SS.ssss. There's no point to this because

// we can't express such times with the NSDatePicker control, so we

// just chop it off.

int32_t dot = aTime.Find(".", false, 0, -1);

if (dot != kNotFound) {

if (dot != 8) return false; // H:MM:SS.ssss not allowed

if (aStep >= 60.0) return false; // HH:MM required

aTime.SetLength(8);

} else {

if (aStep >= 60.0 && aTime.Length() != 5)

return false;

if (aStep < 60.0 && aTime.Length() != 8)

return false;

}

// Length is validated, so the loop here suffices for both cases.

const char16_t *cur = aTime.BeginReading();

const char16_t *end = aTime.EndReading();

size_t nchar = 0;

for (; cur < end; ++cur) {

nchar++;

if (nchar == 3 || nchar == 6) {

if (char16_t(':') == *cur)

continue;

return false;

}

if (char16_t('0') > *cur || char16_t('9') < *cur)

return false;

}

return true;

}

nsresult

HTMLInputElement::InitTimePicker(bool aNoMatterWhat)

{

if (mPickerRunning) {

NS_WARNING("Just one nsITimePicker is allowed");

return NS_ERROR_FAILURE;

}

nsCOMPtr<nsIDocument> doc = OwnerDoc();

nsCOMPtr<nsPIDOMWindow> win = doc->GetWindow();

if (!win) {

return NS_ERROR_FAILURE;

}

if (!aNoMatterWhat && IsPopupBlocked()) {

win->FirePopupBlockedEvent(doc, nullptr, EmptyString(), EmptyString());

return NS_OK;

}

nsCOMPtr<nsITimePicker> timePicker = do_CreateInstance("@mozilla.org/timepicker;1");

if (!timePicker) {

return NS_ERROR_FAILURE;

}

nsAutoString initialValue;

GetValueInternal(initialValue);

// Step value is apparently in milliseconds.

double step = GetStep().toDouble() / 1000.0;

if (step == 0.0) step = 60.0; // XXX?

nsresult rv = timePicker->Init(win, EmptyString()); // title NYI

NS_ENSURE_SUCCESS(rv, rv);

rv = timePicker->SetStep(step);

NS_ENSURE_SUCCESS(rv, rv);

if (IsTimeInRightFormat(initialValue, step)) {

// Sanitized, therefore safe to give to the Cocoa time formatter.

rv = timePicker->SetDefaultTime(initialValue);

NS_ENSURE_SUCCESS(rv, rv);

}

if (HasAttr(kNameSpaceID_None, nsGkAtoms::min)) {

nsAutoString minStr;

GetAttr(kNameSpaceID_None, nsGkAtoms::min, minStr);

if (IsTimeInRightFormat(minStr, step)) {

rv = timePicker->SetMinTime(minStr);

NS_ENSURE_SUCCESS(rv, rv);

}

}

if (HasAttr(kNameSpaceID_None, nsGkAtoms::max)) {

nsAutoString maxStr;

GetAttr(kNameSpaceID_None, nsGkAtoms::max, maxStr);

if (IsTimeInRightFormat(maxStr, step)) {

rv = timePicker->SetMaxTime(maxStr);

NS_ENSURE_SUCCESS(rv, rv);

}

}

nsCOMPtr<nsITimePickerShownCallback> callback =

new nsTimePickerShownCallback(this, timePicker);

rv = timePicker->Open(callback);

if (NS_SUCCEEDED(rv)) {

mPickerRunning = true;

}

return rv;

}

static bool

IsDateInRightFormat(const nsAutoString& aDate)

{

// Avoid exposing web-defined date strings to OS X, since I have

// no idea what crap lurks in there. Instead, ensure the string

// is in nnnn-nn-nn format, and assume NSDateFormatter handles days

// and months that are out of range and rejects those as long as

// the basic format is acceptable.

if (aDate.Length() != 10)

return false;

const char16_t *cur = aDate.BeginReading();

const char16_t *end = aDate.EndReading();

size_t nchar = 0;

for (; cur < end; ++cur) {

nchar++;

if (nchar == 5 || nchar == 8) {

if (char16_t('-') == *cur)

continue;

return false;

}

if (char16_t('0') > *cur || char16_t('9') < *cur)

return false;

}

return true;

}

nsresult

HTMLInputElement::InitDatePicker(bool aNoMatterWhat)

{

if (mPickerRunning) {

NS_WARNING("Just one nsIDatePicker is allowed");

return NS_ERROR_FAILURE;

}

nsCOMPtr<nsIDocument> doc = OwnerDoc();

nsCOMPtr<nsPIDOMWindow> win = doc->GetWindow();

if (!win) {

return NS_ERROR_FAILURE;

}

if (!aNoMatterWhat && IsPopupBlocked()) {

win->FirePopupBlockedEvent(doc, nullptr, EmptyString(), EmptyString());

return NS_OK;

}

nsCOMPtr<nsIDatePicker> datePicker = do_CreateInstance("@mozilla.org/datepicker;1");

if (!datePicker) {

return NS_ERROR_FAILURE;

}

nsAutoString initialValue;

GetValueInternal(initialValue);

nsresult rv = datePicker->Init(win, EmptyString()); // title NYI

NS_ENSURE_SUCCESS(rv, rv);

if (IsDateInRightFormat(initialValue)) {

// Sanitized, therefore safe to give to the Cocoa date formatter.

rv = datePicker->SetDefaultDate(initialValue);

NS_ENSURE_SUCCESS(rv, rv);

}

if (HasAttr(kNameSpaceID_None, nsGkAtoms::min)) {

nsAutoString minStr;

GetAttr(kNameSpaceID_None, nsGkAtoms::min, minStr);

if (IsDateInRightFormat(minStr)) {

rv = datePicker->SetMinDate(minStr);

NS_ENSURE_SUCCESS(rv, rv);

}

}

if (HasAttr(kNameSpaceID_None, nsGkAtoms::max)) {

nsAutoString maxStr;

GetAttr(kNameSpaceID_None, nsGkAtoms::max, maxStr);

if (IsDateInRightFormat(maxStr)) {

rv = datePicker->SetMaxDate(maxStr);

NS_ENSURE_SUCCESS(rv, rv);

}

}

nsCOMPtr<nsIDatePickerShownCallback> callback =

new nsDatePickerShownCallback(this, datePicker);

rv = datePicker->Open(callback);

if (NS_SUCCEEDED(rv)) {

mPickerRunning = true;

}

return rv;

}

nsresult

HTMLInputElement::InitColorPicker()

{

if (mPickerRunning) {

NS_WARNING("Just one nsIColorPicker is allowed");

return NS_ERROR_FAILURE;

}

nsCOMPtr<nsIDocument> doc = OwnerDoc();

nsCOMPtr<nsPIDOMWindow> win = doc->GetWindow();

if (!win) {

return NS_ERROR_FAILURE;

}

if (IsPopupBlocked()) {

win->FirePopupBlockedEvent(doc, nullptr, EmptyString(), EmptyString());

return NS_OK;

}

// Get Loc title

nsXPIDLString title;

nsContentUtils::GetLocalizedString(nsContentUtils::eFORMS_PROPERTIES,

"ColorPicker", title);

nsCOMPtr<nsIColorPicker> colorPicker = do_CreateInstance("@mozilla.org/colorpicker;1");

if (!colorPicker) {

return NS_ERROR_FAILURE;

}

nsAutoString initialValue;

GetValueInternal(initialValue);

nsresult rv = colorPicker->Init(win, title, initialValue);

NS_ENSURE_SUCCESS(rv, rv);

nsCOMPtr<nsIColorPickerShownCallback> callback =

new nsColorPickerShownCallback(this, colorPicker);

rv = colorPicker->Open(callback);

if (NS_SUCCEEDED(rv)) {

mPickerRunning = true;

}

return rv;

}

nsresult

HTMLInputElement::InitFilePicker(FilePickerType aType)

{

if (mPickerRunning) {

NS_WARNING("Just one nsIFilePicker is allowed");

return NS_ERROR_FAILURE;

}

// Get parent nsPIDOMWindow object.

nsCOMPtr<nsIDocument> doc = OwnerDoc();

nsCOMPtr<nsPIDOMWindow> win = doc->GetWindow();

if (!win) {

return NS_ERROR_FAILURE;

}

if (IsPopupBlocked()) {

win->FirePopupBlockedEvent(doc, nullptr, EmptyString(), EmptyString());

return NS_OK;

}

// Get Loc title

nsXPIDLString title;

nsContentUtils::GetLocalizedString(nsContentUtils::eFORMS_PROPERTIES,

"FileUpload", title);

nsCOMPtr<nsIFilePicker> filePicker = do_CreateInstance("@mozilla.org/filepicker;1");

if (!filePicker)

return NS_ERROR_FAILURE;

int16_t mode;

if (aType == FILE_PICKER_DIRECTORY) {

mode = static_cast<int16_t>(nsIFilePicker::modeGetFolder);

} else if (HasAttr(kNameSpaceID_None, nsGkAtoms::multiple)) {

mode = static_cast<int16_t>(nsIFilePicker::modeOpenMultiple);

} else {

mode = static_cast<int16_t>(nsIFilePicker::modeOpen);

}

nsresult rv = filePicker->Init(win, title, mode);

NS_ENSURE_SUCCESS(rv, rv);

// Native directory pickers ignore file type filters, so we don't spend

// cycles adding them for FILE_PICKER_DIRECTORY.

if (HasAttr(kNameSpaceID_None, nsGkAtoms::accept) &&

aType != FILE_PICKER_DIRECTORY) {

SetFilePickerFiltersFromAccept(filePicker);

} else {

filePicker->AppendFilters(nsIFilePicker::filterAll);

}

// Set default directry and filename

nsAutoString defaultName;

const nsTArray<RefPtr<File>>& oldFiles = GetFilesInternal();

nsCOMPtr<nsIFilePickerShownCallback> callback =

new HTMLInputElement::nsFilePickerShownCallback(this, filePicker);

if (!oldFiles.IsEmpty() &&

aType != FILE_PICKER_DIRECTORY) {