DevTools: Replace multiline InplaceEditor with CodeMirrorTextEditor

third_party/WebKit/Source/devtools/front_end/ui/InplaceEditor.js

 // Copyright 2014 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.
 /**
  * @unrestricted
  */
 UI.InplaceEditor = class {
   /**
    * @param {!Element} element
    * @param {!UI.InplaceEditor.Config=} config
    * @return {?UI.InplaceEditor.Controller}
    */
   static startEditing(element, config) {
     if (!UI.InplaceEditor._defaultInstance)
       UI.InplaceEditor._defaultInstance = new UI.InplaceEditor();
     return UI.InplaceEditor._defaultInstance.startEditing(element, config);
   }
 
   /**
-   * @param {!Element} element
-   * @param {!UI.InplaceEditor.Config=} config
-   * @return {!Promise.<!UI.InplaceEditor.Controller>}
-   */
-  static startMultilineEditing(element, config) {
-    return self.runtime.extension(UI.InplaceEditor).instance().then(startEditing);
-
-    /**
-     * @param {!Object} inplaceEditor
-     * @return {!UI.InplaceEditor.Controller|!Promise.<!UI.InplaceEditor.Controller>}
-     */
-    function startEditing(inplaceEditor) {
-      var controller = /** @type {!UI.InplaceEditor} */ (inplaceEditor).startEditing(element, config);
-      if (!controller)
-        return Promise.reject(new Error('Editing is already in progress'));
-      return controller;
-    }
-  }
-
-  /**
    * @return {string}
    */
   editorContent(editingContext) {
     var element = editingContext.element;
     if (element.tagName === 'INPUT' && element.type === 'text')
       return element.value;
 
     return element.textContent;
   }
 
@@ skipping 39 matching lines @@
   startEditing(element, config) {
     if (!UI.markBeingEdited(element, true))
       return null;
 
     config = config || new UI.InplaceEditor.Config(function() {}, function() {});
     var editingContext = {element: element, config: config};
     var committedCallback = config.commitHandler;
     var cancelledCallback = config.cancelHandler;
     var pasteCallback = config.pasteHandler;
     var context = config.context;
-    var isMultiline = config.multiline || false;
     var moveDirection = '';
     var self = this;
 
     this.setUpEditor(editingContext);
 
-    editingContext.oldText = isMultiline ? config.initialValue : this.editorContent(editingContext);
+    editingContext.oldText = this.editorContent(editingContext);
 
     /**
      * @param {!Event=} e
      */
     function blurEventListener(e) {
       if (config.blurHandler && !config.blurHandler(element, e))
         return;
-      if (!isMultiline || !e || !e.relatedTarget || !e.relatedTarget.isSelfOrDescendant(element))
-        editingCommitted.call(element);
+      editingCommitted.call(element);
     }
 
     function cleanUpAfterEditing() {
       UI.markBeingEdited(element, false);
 
-      element.removeEventListener('blur', blurEventListener, isMultiline);
+      element.removeEventListener('blur', blurEventListener, false);
       element.removeEventListener('keydown', keyDownEventListener, true);
       if (pasteCallback)
         element.removeEventListener('paste', pasteEventListener, true);
 
       if (self._focusRestorer)
         self._focusRestorer.restore();
       self.closeEditor(editingContext);
     }
 
     /** @this {Element} */
     function editingCancelled() {
       self.cancelEditing(editingContext);
       cleanUpAfterEditing();
       cancelledCallback(this, context);
     }
 
     /** @this {Element} */
     function editingCommitted() {
       cleanUpAfterEditing();
 
       committedCallback(this, self.editorContent(editingContext), editingContext.oldText, context, moveDirection);
     }
 
     /**
      * @param {!Event} event
      * @return {string}
      */
     function defaultFinishHandler(event) {
-      var isMetaOrCtrl = Host.isMac() ? event.metaKey && !event.shiftKey && !event.ctrlKey && !event.altKey :
-                                        event.ctrlKey && !event.shiftKey && !event.metaKey && !event.altKey;
-      if (isEnterKey(event) && (event.isMetaOrCtrlForTest || !isMultiline || isMetaOrCtrl))
+      if (isEnterKey(event))
         return 'commit';
       else if (event.keyCode === UI.KeyboardShortcut.Keys.Esc.code || event.key === 'Escape')
         return 'cancel';
-      else if (!isMultiline && event.key === 'Tab')
+      else if (event.key === 'Tab')
         return 'move-' + (event.shiftKey ? 'backward' : 'forward');
       return '';
     }
 
     function handleEditingResult(result, event) {
       if (result === 'commit') {
         editingCommitted.call(element);
         event.consume(true);
       } else if (result === 'cancel') {
         editingCancelled.call(element);
@@ skipping 17 matching lines @@
     /**
      * @param {!Event} event
      */
     function keyDownEventListener(event) {
       var result = defaultFinishHandler(event);
       if (!result && config.postKeydownFinishHandler)
         result = config.postKeydownFinishHandler(event);
       handleEditingResult(result, event);
     }
 
-    element.addEventListener('blur', blurEventListener, isMultiline);
+    element.addEventListener('blur', blurEventListener, false);
     element.addEventListener('keydown', keyDownEventListener, true);
     if (pasteCallback)
       element.addEventListener('paste', pasteEventListener, true);
 
-    var handle = {cancel: editingCancelled.bind(element), commit: editingCommitted.bind(element), setWidth() {}};
+    var handle = {cancel: editingCancelled.bind(element), commit: editingCommitted.bind(element)};
     this.augmentEditingHandle(editingContext, handle);
     return handle;
   }
 };
 
 /**
- * @typedef {{cancel: function(), commit: function(), setWidth: function(number)}}
+ * @typedef {{cancel: function(), commit: function()}}
  */
 UI.InplaceEditor.Controller;
 
 
 /**
  * @template T
  * @unrestricted
  */
 UI.InplaceEditor.Config = class {
   /**
    * @param {function(!Element,string,string,T,string)} commitHandler
    * @param {function(!Element,T)} cancelHandler
    * @param {T=} context
    * @param {function(!Element,!Event):boolean=} blurHandler
    */
   constructor(commitHandler, cancelHandler, context, blurHandler) {
     this.commitHandler = commitHandler;
     this.cancelHandler = cancelHandler;
     this.context = context;
     this.blurHandler = blurHandler;
 
     /**
      * @type {function(!Event):string|undefined}
      */
     this.pasteHandler;
 
     /**
-     * @type {boolean|undefined}
-     */
-    this.multiline;
-
-    /**
      * @type {function(!Event):string|undefined}
      */
     this.postKeydownFinishHandler;
   }
 
   setPasteHandler(pasteHandler) {
     this.pasteHandler = pasteHandler;
   }
 
   /**
-   * @param {string} initialValue
-   * @param {!Object} mode
-   * @param {string} theme
-   * @param {boolean=} lineWrapping
-   * @param {boolean=} smartIndent
-   */
-  setMultilineOptions(initialValue, mode, theme, lineWrapping, smartIndent) {
-    this.multiline = true;
-    this.initialValue = initialValue;
-    this.mode = mode;
-    this.theme = theme;
-    this.lineWrapping = lineWrapping;
-    this.smartIndent = smartIndent;
-  }
-
-  /**
    * @param {function(!Event):string} postKeydownFinishHandler
    */
   setPostKeydownFinishHandler(postKeydownFinishHandler) {
     this.postKeydownFinishHandler = postKeydownFinishHandler;
   }
 };