Changing "trans" to "transaction" to address issue in review 1437696

Change-Id: I2bb4ee0d3676dc29dda4de7424ab418637f59803
Reviewed-on: https://chromium-review.googlesource.com/c/1483450Reviewed-by: Maks Orlovich <morlovich@chromium.org>
Reviewed-by: Shivani Sharma <shivanisha@chromium.org>
Commit-Queue: Steven Bingler <bingler@chromium.org>
Cr-Commit-Position: refs/heads/master@{#635173}

net/http/http_cache.h

@@ -256,7 +256,7 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory {
 
   // HttpTransactionFactory implementation:
   int CreateTransaction(RequestPriority priority,
-                        std::unique_ptr<HttpTransaction>* trans) override;
+                        std::unique_ptr<HttpTransaction>* transaction) override;
   HttpCache* GetCache() override;
   HttpNetworkSession* GetSession() override;
 
@@ -402,11 +402,11 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory {
                     CompletionOnceCallback callback);
 
   // Makes sure that the backend creation is complete before allowing the
-  // provided transaction to use the object. Returns an error code.  |trans|
-  // will be notified via its IO callback if this method returns ERR_IO_PENDING.
-  // The transaction is free to use the backend directly at any time after
-  // receiving the notification.
-  int GetBackendForTransaction(Transaction* trans);
+  // provided transaction to use the object. Returns an error code.
+  // |transaction| will be notified via its IO callback if this method returns
+  // ERR_IO_PENDING. The transaction is free to use the backend directly at any
+  // time after receiving the notification.
+  int GetBackendForTransaction(Transaction* transaction);
 
   // Generates the cache key for this request.
   std::string GenerateCacheKey(const HttpRequestInfo*);
@@ -415,17 +415,17 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory {
   // entries.
   void DoomActiveEntry(const std::string& key);
 
-  // Dooms the entry selected by |key|. |trans| will be notified via its IO
-  // callback if this method returns ERR_IO_PENDING. The entry can be
-  // currently in use or not. If entry is in use and the invoking transaction
-  // is associated with this entry and this entry is already doomed, this API
+  // Dooms the entry selected by |key|. |transaction| will be notified via its
+  // IO callback if this method returns ERR_IO_PENDING. The entry can be
+  // currently in use or not. If entry is in use and the invoking transaction is
+  // associated with this entry and this entry is already doomed, this API
   // should not be invoked.
-  int DoomEntry(const std::string& key, Transaction* trans);
+  int DoomEntry(const std::string& key, Transaction* transaction);
 
-  // Dooms the entry selected by |key|. |trans| will be notified via its IO
-  // callback if this method returns ERR_IO_PENDING. The entry should not
-  // be currently in use.
-  int AsyncDoomEntry(const std::string& key, Transaction* trans);
+  // Dooms the entry selected by |key|. |transaction| will be notified via its
+  // IO callback if this method returns ERR_IO_PENDING. The entry should not be
+  // currently in use.
+  int AsyncDoomEntry(const std::string& key, Transaction* transaction);
 
   // Dooms the entry associated with a GET for a given |url|, loaded from
   // a page with top-level frame at |top_frame_origin|.
@@ -456,27 +456,29 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory {
   void DeletePendingOp(PendingOp* pending_op);
 
   // Opens the disk cache entry associated with |key|, creating the entry if it
-  // does not already exist, returning an ActiveEntry in |*entry|. |trans| will
-  // be notified via its IO callback if this method returns ERR_IO_PENDING. This
-  // should not be called if there already is an active entry associated with
-  // |key|, e.g. you should call FindActiveEntry first.
+  // does not already exist, returning an ActiveEntry in |*entry|. |transaction|
+  // will be notified via its IO callback if this method returns ERR_IO_PENDING.
+  // This should not be called if there already is an active entry associated
+  // with |key|, e.g. you should call FindActiveEntry first.
   int OpenOrCreateEntry(const std::string& key,
                         ActiveEntry** entry,
-                        Transaction* trans);
+                        Transaction* transaction);
 
   // Opens the disk cache entry associated with |key|, returning an ActiveEntry
-  // in |*entry|. |trans| will be notified via its IO callback if this method
-  // returns ERR_IO_PENDING. This should not be called if there already is
-  // an active entry associated with |key|, e.g. you should call FindActiveEntry
-  // first.
-  int OpenEntry(const std::string& key, ActiveEntry** entry,
-                Transaction* trans);
+  // in |*entry|. |transaction| will be notified via its IO callback if this
+  // method returns ERR_IO_PENDING. This should not be called if there already
+  // is an active entry associated with |key|, e.g. you should call
+  // FindActiveEntry first.
+  int OpenEntry(const std::string& key,
+                ActiveEntry** entry,
+                Transaction* transaction);
 
   // Creates the disk cache entry associated with |key|, returning an
-  // ActiveEntry in |*entry|. |trans| will be notified via its IO callback if
-  // this method returns ERR_IO_PENDING.
-  int CreateEntry(const std::string& key, ActiveEntry** entry,
-                  Transaction* trans);
+  // ActiveEntry in |*entry|. |transaction| will be notified via its IO callback
+  // if this method returns ERR_IO_PENDING.
+  int CreateEntry(const std::string& key,
+                  ActiveEntry** entry,
+                  Transaction* transaction);
 
   // Destroys an ActiveEntry (active or doomed). Should only be called if
   // entry->SafeToDestroy() returns true.
@@ -581,19 +583,20 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory {
   bool IsWritingInProgress(ActiveEntry* entry) const;
 
   // Returns the LoadState of the provided pending transaction.
-  LoadState GetLoadStateForPendingTransaction(const Transaction* trans);
+  LoadState GetLoadStateForPendingTransaction(const Transaction* transaction);
 
-  // Removes the transaction |trans|, from the pending list of an entry
+  // Removes the transaction |transaction|, from the pending list of an entry
   // (PendingOp, active or doomed entry).
-  void RemovePendingTransaction(Transaction* trans);
+  void RemovePendingTransaction(Transaction* transaction);
 
-  // Removes the transaction |trans|, from the pending list of |entry|.
+  // Removes the transaction |transaction|, from the pending list of |entry|.
   bool RemovePendingTransactionFromEntry(ActiveEntry* entry,
-                                         Transaction* trans);
+                                         Transaction* transaction);
 
-  // Removes the transaction |trans|, from the pending list of |pending_op|.
+  // Removes the transaction |transaction|, from the pending list of
+  // |pending_op|.
   bool RemovePendingTransactionFromPendingOp(PendingOp* pending_op,
-                                             Transaction* trans);
+                                             Transaction* transaction);
 
   // Events (called via PostTask) ---------------------------------------------