gitiles: go back to QueryEscape because url.PathEscape is not in Go1.6.

common/api/gitiles/gitiles.go

 // Copyright 2016 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 120 matching lines @@
 //  Log(C) = [C, A, B, base, common...]
 //
 func (c *Client) Log(ctx context.Context, repoURL, treeish string, limit int) ([]Commit, error) {
         repoURL, err := NormalizeRepoURL(repoURL)
         if err != nil {
                 return nil, err
         }
         if limit < 1 {
                 return nil, fmt.Errorf("limit must be at least 1, but %d provided", limit)
         }
-        subPath := fmt.Sprintf("+log/%s?format=JSON", url.PathEscape(treeish))
+        // TODO(tandrii): s/QueryEscape/PathEscape once AE deployments are Go1.8+.
+        subPath := fmt.Sprintf("+log/%s?format=JSON", url.QueryEscape(treeish))
         resp := &logResponse{}
         if err := c.get(ctx, repoURL, subPath, resp); err != nil {
                 return nil, err
         }
         result := resp.Log
         for {
                 if resp.Next == "" || len(result) >= limit {
                         if len(result) > limit {
                                 result = result[:limit]
                         }
@@ skipping 32 matching lines @@
 func (c *Client) Refs(ctx context.Context, repoURL, refsPath string) (map[string]string, error) {
         repoURL, err := NormalizeRepoURL(repoURL)
         if err != nil {
                 return nil, err
         }
         if refsPath != "refs" && !strings.HasPrefix(refsPath, "refs/") {
                 return nil, fmt.Errorf("refsPath must start with \"refs\": %q", refsPath)
         }
         refsPath = strings.TrimRight(refsPath, "/")
 
-        subPath := fmt.Sprintf("+%s?format=json", url.PathEscape(refsPath))
+        // TODO(tandrii): s/QueryEscape/PathEscape once AE deployments are Go1.8+.
+        subPath := fmt.Sprintf("+%s?format=json", url.QueryEscape(refsPath))
         resp := refsResponse{}
         if err := c.get(ctx, repoURL, subPath, &resp); err != nil {
                 return nil, err
         }
         r := make(map[string]string, len(resp))
         for ref, v := range resp {
                 switch {
                 case v.Value == "":
                         // Weird case of what looks like hash with a target in at least Chromium
                         // repo.
@@ skipping 52 matching lines @@
                 return errors.Annotate(err, "unexpected response from Gitiles").Err()
         }
         if cnt != 4 || ")]}'" != string(trash) {
                 return errors.New("unexpected response from Gitiles")
         }
         if err = json.NewDecoder(r.Body).Decode(result); err != nil {
                 return errors.Annotate(err, "failed to decode Gitiles response into %T", result).Err()
         }
         return nil
 }