First stab at using Rietveld wrapper object in both gcl.py and git-cl.

git_cl.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
 """A git-command for integrating reviews on Rietveld."""
 
 import errno
@@ skipping 21 matching lines @@
   except ImportError:
     # Fall back to the packaged version.
     sys.path.append(os.path.join(os.path.dirname(__file__), 'third_party'))
     import simplejson as json  # pylint: disable=F0401
 
 
 from third_party import upload
 import breakpad  # pylint: disable=W0611
 import fix_encoding
 import presubmit_support
+import rietveld
 import scm
 import watchlists
 
 
 
 DEFAULT_SERVER = 'http://codereview.appspot.com'
 POSTUPSTREAM_HOOK_PATTERN = '.git/hooks/post-cl-%s'
 DESCRIPTION_BACKUP_FILE = '~/.git_cl_description_backup'
 
 
@@ skipping 404 matching lines @@
     return self.rietveld_server
 
   def GetIssueURL(self):
     """Get the URL for a particular issue."""
     return '%s/%s' % (self.GetRietveldServer(), self.GetIssue())
 
   def GetDescription(self, pretty=False):
     if not self.has_description:
       if self.GetIssue():
         path = '/' + self.GetIssue() + '/description'
-        rpc_server = self._RpcServer()
+        rpc_server = self.RpcServer()
         self.description = rpc_server.Send(path).strip()
       self.has_description = True
     if pretty:
       wrapper = textwrap.TextWrapper()
       wrapper.initial_indent = wrapper.subsequent_indent = '  '
       return wrapper.fill(self.description)
     return self.description
 
   def GetPatchset(self):
     if not self.has_patchset:
@@ skipping 10 matching lines @@
     """Set this branch's patchset.  If patchset=0, clears the patchset."""
     if patchset:
       RunGit(['config', self._PatchsetSetting(), str(patchset)])
     else:
       RunGit(['config', '--unset', self._PatchsetSetting()],
              swallow_stderr=True, error_ok=True)
     self.has_patchset = False
 
   def GetPatchSetDiff(self, issue):
     # Grab the last patchset of the issue first.
-    data = json.loads(self._RpcServer().Send('/api/%s' % issue))
+    data = json.loads(self.RpcServer().Send('/api/%s' % issue))
     patchset = data['patchsets'][-1]
-    return self._RpcServer().Send(
+    return self.RpcServer().Send(
         '/download/issue%s_%s.diff' % (issue, patchset))
 
   def SetIssue(self, issue):
     """Set this branch's issue.  If issue=0, clears the issue."""
     if issue:
       RunGit(['config', self._IssueSetting(), str(issue)])
       if self.rietveld_server:
         RunGit(['config', self._RietveldServer(), self.rietveld_server])
     else:
       RunGit(['config', '--unset', self._IssueSetting()])
       self.SetPatchset(0)
     self.has_issue = False
 
   def CloseIssue(self):
-    rpc_server = self._RpcServer()
+    rpc_server = self.RpcServer()
     # Newer versions of Rietveld require us to pass an XSRF token to POST, so
     # we fetch it from the server.  (The version used by Chromium has been
     # modified so the token isn't required when closing an issue.)
     xsrf_token = rpc_server.Send('/xsrf_token',
                                  extra_headers={'X-Requesting-XSRF-Token': '1'})
 
     # You cannot close an issue with a GET.
     # We pass an empty string for the data so it is a POST rather than a GET.
     data = [("description", self.description),
             ("xsrf_token", xsrf_token)]
     ctype, body = upload.EncodeMultipartFormData(data, [])
-    rpc_server.Send('/' + self.GetIssue() + '/close', body, ctype)
+    rpc_server.Send(
+        '/' + self.GetIssue() + '/close', payload=body, content_type=ctype)
 
-  def _RpcServer(self):
+  def RpcServer(self):
     """Returns an upload.RpcServer() to access this review's rietveld instance.
     """
     if not self._rpc_server:
-      server = self.GetRietveldServer()
-      self._rpc_server = upload.GetRpcServer(server, save_cookies=True)
+      self.GetIssue()
+      self._rpc_server = rietveld.Rietveld(self.rietveld_server, None, None)
     return self._rpc_server
 
   def _IssueSetting(self):
     """Return the git setting that stores this change's issue."""
     return 'branch.%s.rietveldissue' % self.GetBranch()
 
   def _PatchsetSetting(self):
     """Return the git setting that stores this change's most recent patchset."""
     return 'branch.%s.rietveldpatchset' % self.GetBranch()
 
@@ skipping 297 matching lines @@
   # Apply watchlists on upload.
   if not committing:
     watchlist = watchlists.Watchlists(change.RepositoryRoot())
     files = [f.LocalPath() for f in change.AffectedFiles()]
     cl.SetWatchers(watchlist.GetWatchersForPaths(files))
 
   try:
     output = presubmit_support.DoPresubmitChecks(change, committing,
         verbose=verbose, output_stream=sys.stdout, input_stream=sys.stdin,
         default_presubmit=None, may_prompt=may_prompt, tbr=tbr,
-        host_url=cl.GetRietveldServer())
+        rietveld=cl.RpcServer())
   except presubmit_support.PresubmitFailure, e:
     DieWithError(
         ('%s\nMaybe your depot_tools is out of date?\n'
          'If all fails, contact maruel@') % e)
 
   # TODO(dpranke): We should propagate the error out instead of calling exit().
   if not output.should_continue():
     sys.exit(1)
 
   return output
@@ skipping 581 matching lines @@
              'and retry or visit go/isgaeup.\n%s') % (e.code, str(e)))
 
   # Not a known command. Default to help.
   GenUsage(parser, 'help')
   return CMDhelp(parser, argv)
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   sys.exit(main(sys.argv[1:]))