Chrome OS "open with" picker allowing Web Intents

chrome/test/data/extensions/api_test/filebrowser_component/main.js

 // 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.
 
 /*
 This component extension test does the following:
 
 1. Creates an abc and log file on the local file system with some random text.
 2. Finds a registered task (file item context menu) for abc file and invokes it
    with url of the test file.
@@ skipping 46 matching lines @@
 
   if (!this.file_ || !this.fileText_ || !this.fileVerifierFunction_) {
     callback({message: "Test expectations not set properly."});
     return;
   }
 
   this.fileVerifierFunction_(this.file_, this.fileText_, request,
                              callback);
 };
 
+TestExpectations.prototype.hasVerifyStep = function() {
+  return !!this.fileVerifierFunction_;
+};
+
 // Verifies that list of tasks |tasks| contains tasks specified in
 // expectedTasks_. |successCallback| expects to be passed |tasks|.
 // |errorCallback| expects error object.
 TestExpectations.prototype.verifyTasks = function(tasks,
                                                   successCallback,
                                                   errorCallback) {
   if (tasks.length != Object.keys(this.expectedTasks_).length) {
     errorCallback({message: 'Wrong number of tasks found.'});
     return;
   }
 
   for (var i = 0; i < tasks.length; ++i) {
-    var taskName = /^.*[|](\w+)$/.exec(tasks[i].taskId)[1];
+    var taskName = /^.*[|](\S+)$/.exec(tasks[i].taskId)[1];
     var patterns = tasks[i].patterns;
     var expectedPatterns = this.expectedTasks_[taskName];
     if (!expectedPatterns) {
-      errorCallback({message: 'Wrong task from getFileTasks(): ' + task_name});
+      errorCallback({message: 'Wrong task from getFileTasks(): ' + taskName});
       return;
     }
     patterns = patterns.sort();
     expectedPatterns = expectedPatterns.sort();
     for (var j = 0; j < patterns.length; ++j) {
       var translatedPattern = expectedPatterns[j].replace(
           /^filesystem:/, "chrome-extension://*/");
       if (patterns[j] != translatedPattern) {
         errorCallback({message: 'Wrong patterns set for task ' +
                                 taskName + '. ' +
@@ skipping 31 matching lines @@
   this.fileCreator_.init(fs, this.onFileCreatorInit_.bind(this),
                              this.errorCallback_.bind(this));
 };
 
 TestRunner.prototype.onFileCreatorInit_ = function() {
   var ext = this.expectations_.getFileExtension();
   if (!ext) {
     this.errorCallback_({message: "Test file extension not set."});
     return;
   }
-  console.log(this.fileExtension);
   var self = this;
   this.fileCreator_.createFile('.log',
       function(file, text) {
         self.fileCreator_.createFile(ext,
             self.onFileCreated_.bind(self),
             self.errorCallback_.bind(self));
       },
       this.errorCallback_.bind(this));
 };
 
@@ skipping 17 matching lines @@
 
   console.log('DONE fetching ' + tasks.length + ' tasks');
 
   this.expectations_.verifyTasks(tasks,
                                  this.onTasksVerified_.bind(this, fileUrl),
                                  this.errorCallback_.bind(this));
 }
 
 TestRunner.prototype.onTasksVerified_ = function(fileUrl, tasks) {
   chrome.fileBrowserPrivate.executeTask(tasks[0].taskId, [fileUrl]);
+
+  if (!this.expectations_.hasVerifyStep()) {
+    console.log('Not verifying content, succeed immediately.');
+    this.reportSuccess_();
+  }
 };
 
 TestRunner.prototype.errorCallback_ = function(error) {
   var msg = '';
   if (!error.code) {
     msg = error.message;
   } else {
     switch (error.code) {
       case FileError.QUOTA_EXCEEDED_ERR:
         msg = 'QUOTA_EXCEEDED_ERR';
@@ skipping 43 matching lines @@
   if (!error) {
     sendResponse({success: true});
     this.fileCreator_.cleanupAndEndTest(this.reportSuccess_.bind(this),
                                         this.reportFail_.bind(this,
                                                               cleanupError));
   } else {
     sendResponse({success: false});
     this.errorCallback_(error);
   }
 };