Update callers of httputils.ReportError to specify message

ct/go/ctfe/task_common/task_common.go

 /*
         Handlers, types, and functions common to all types of tasks.
 */
 
 package task_common
 
 import (
         "database/sql"
         "encoding/json"
         "fmt"
@@ skipping 80 matching lines @@
 func (vars *AddTaskCommonVars) GetAddTaskCommonVars() *AddTaskCommonVars {
         return vars
 }
 
 func (vars *AddTaskCommonVars) IsAdminTask() bool {
         return false
 }
 
 func AddTaskHandler(w http.ResponseWriter, r *http.Request, task AddTaskVars) {
         if !ctfeutil.UserHasEditRights(r) {
-                httputils.ReportError(w, r, fmt.Errorf("Must have google or chromium account to add tasks"), "")
+                httputils.ReportError(w, r, nil, "Please login with google or chromium account to add tasks")
                 return
         }
         if task.IsAdminTask() && !ctfeutil.UserHasAdminRights(r) {
-                httputils.ReportError(w, r, fmt.Errorf("Must be admin to add admin tasks; contact rmistry@"), "")
+                httputils.ReportError(w, r, nil, "Must be admin to add admin tasks; contact rmistry@")
                 return
         }
         w.Header().Set("Content-Type", "application/json")
         if err := json.NewDecoder(r.Body).Decode(&task); err != nil {
                 httputils.ReportError(w, r, err, fmt.Sprintf("Failed to add %T task", task))
                 return
         }
         defer skutil.Close(r.Body)
 
         task.GetAddTaskCommonVars().Username = login.LoggedInAs(r)
         task.GetAddTaskCommonVars().TsAdded = ctutil.GetCurrentTs()
         if len(task.GetAddTaskCommonVars().Username) > 255 {
-                httputils.ReportError(w, r, fmt.Errorf("Username is too long, limit 255 bytes"), "")
+                httputils.ReportError(w, r, nil, "Username is too long, limit 255 bytes")
                 return
         }
 
         if _, err := AddTask(task); err != nil {
                 httputils.ReportError(w, r, err, fmt.Sprintf("Failed to insert %T task", task))
                 return
         }
 }
 
 // Returns the ID of the inserted task if the operation was successful.
@@ skipping 72 matching lines @@
         if !params.CountQuery {
                 query += " ORDER BY id DESC LIMIT ?,?"
                 args = append(args, params.Offset, params.Size)
         }
         return query, args
 }
 
 func GetTaskStatusHandler(prototype Task, w http.ResponseWriter, r *http.Request) {
         taskID := r.FormValue("task_id")
         if taskID == "" {
-                httputils.ReportError(w, r, fmt.Errorf("Missing required parameter task_id"), "")
+                httputils.ReportError(w, r, nil, "Missing required parameter task_id")
                 return
         }
 
         rowQuery := fmt.Sprintf("SELECT * FROM %s WHERE id = ?", prototype.TableName())
         data, err := prototype.Select(rowQuery, taskID)
         if err != nil {
-                httputils.ReportError(w, r, fmt.Errorf("Could not find %s task with ID %s", prototype.GetTaskName(), taskID), "")
+                httputils.ReportError(w, r, nil, fmt.Sprintf("Could not find %s task with ID %s", prototype.GetTaskName(), taskID))

[dogben, 2016/03/21 18:54:38]

taskID is not sanitized.

Same below.

[rmistry, 2016/03/21 18:56:42]

What do you mean by sanitized?

                 return
         }
         tasks := AsTaskSlice(data)
         if len(tasks) == 0 {
-                httputils.ReportError(w, r, fmt.Errorf("Could not find %s task with ID %s", prototype.GetTaskName(), taskID), "")
+                httputils.ReportError(w, r, nil, fmt.Sprintf("Could not find %s task with ID %s", prototype.GetTaskName(), taskID))
                 return
         }
 
         status := "Pending"
         resultsLink := tasks[0].GetResultsLink()
         if tasks[0].GetCommonCols().TsCompleted.Valid {
                 status = "Completed"
                 if tasks[0].GetCommonCols().Failure.Valid && tasks[0].GetCommonCols().Failure.Bool {
                         status += " with failures"
                 }
@@ skipping 31 matching lines @@
 func GetTasksHandler(prototype Task, w http.ResponseWriter, r *http.Request) {
         w.Header().Set("Content-Type", "application/json")
 
         params := QueryParams{}
         params.Username = r.FormValue("username")
         params.SuccessfulOnly = parseBoolFormValue(r.FormValue("successful"))
         params.PendingOnly = parseBoolFormValue(r.FormValue("not_completed"))
         params.FutureRunsOnly = parseBoolFormValue(r.FormValue("include_future_runs"))
         params.ExcludeDummyPageSets = parseBoolFormValue(r.FormValue("exclude_dummy_page_sets"))
         if params.SuccessfulOnly && params.PendingOnly {
-                httputils.ReportError(w, r, fmt.Errorf("Inconsistent params: successful %v not_completed %v", r.FormValue("successful"), r.FormValue("not_completed")), "")
+                httputils.ReportError(w, r, fmt.Errorf("Inconsistent params: successful %v not_completed %v", r.FormValue("successful"), r.FormValue("not_completed")), "Inconsistent params")
                 return
         }
         if params.ExcludeDummyPageSets && !HasPageSetsColumn(prototype) {
-                httputils.ReportError(w, r, fmt.Errorf("Task %s does not use page sets and thus cannot exclude dummy page sets.", prototype.GetTaskName()), "")
+                httputils.ReportError(w, r, nil, fmt.Sprintf("Task %s does not use page sets and thus cannot exclude dummy page sets.", prototype.GetTaskName()))
                 return
         }
         offset, size, err := httputils.PaginationParams(r.URL.Query(), 0, DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE)
         if err == nil {
                 params.Offset, params.Size = offset, size
         } else {
                 httputils.ReportError(w, r, err, "Failed to get pagination params")
                 return
         }
         params.CountQuery = false
@@ skipping 173 matching lines @@
 // error describing the problem.
 func canRedoTask(task Task, r *http.Request) (bool, error) {
         if !task.GetCommonCols().TsCompleted.Valid {
                 return false, fmt.Errorf("Cannot redo pending tasks.")
         }
         return true, nil
 }
 
 func DeleteTaskHandler(prototype Task, w http.ResponseWriter, r *http.Request) {
         if !ctfeutil.UserHasEditRights(r) {
-                httputils.ReportError(w, r, fmt.Errorf("Must have google or chromium account to delete tasks"), "")
+                httputils.ReportError(w, r, nil, "Please login with google or chromium account to delete tasks")
                 return
         }
         w.Header().Set("Content-Type", "application/json")
         vars := struct{ Id int64 }{}
         if err := json.NewDecoder(r.Body).Decode(&vars); err != nil {
                 httputils.ReportError(w, r, err, "Failed to parse delete request")
                 return
         }
         defer skutil.Close(r.Body)
         requireUsernameMatch := !ctfeutil.UserHasAdminRights(r)
@@ skipping 21 matching lines @@
         if err != nil {
                 httputils.ReportError(w, r, err, "Unable to validate request.")
                 return
         }
         tasks := AsTaskSlice(data)
         if len(tasks) != 1 {
                 // Row already deleted; return success.
                 return
         }
         if ok, err := canDeleteTask(tasks[0], r); !ok {
-                httputils.ReportError(w, r, err, "")
+                httputils.ReportError(w, r, err, "Do not have permission to delete task")
         } else {
-                httputils.ReportError(w, r, fmt.Errorf("Failed to delete; reason unknown"), "")
+                httputils.ReportError(w, r, nil, "Failed to delete; reason unknown")
                 return
         }
 }
 
 func RedoTaskHandler(prototype Task, w http.ResponseWriter, r *http.Request) {
         if !ctfeutil.UserHasEditRights(r) {
-                httputils.ReportError(w, r, fmt.Errorf("Must have google or chromium account to redo tasks"), "")
+                httputils.ReportError(w, r, nil, "Please login with google or chromium account to redo tasks")
                 return
         }
         w.Header().Set("Content-Type", "application/json")
         vars := struct{ Id int64 }{}
         if err := json.NewDecoder(r.Body).Decode(&vars); err != nil {
                 httputils.ReportError(w, r, err, "Failed to parse redo request")
                 return
         }
         defer skutil.Close(r.Body)
 
@@ skipping 33 matching lines @@
 
         if err := json.NewEncoder(w).Encode(pageSets); err != nil {
                 httputils.ReportError(w, r, err, fmt.Sprintf("Failed to encode JSON: %v", err))
                 return
         }
 }
 
 func AddHandlers(r *mux.Router) {
         r.HandleFunc("/"+ctfeutil.PAGE_SETS_PARAMETERS_POST_URI, pageSetsHandler).Methods("POST")
 }