Remove unnecessary calls to GURL()

components/drive/drive_uploader_unittest.cc

 // 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.
 
 #include "components/drive/drive_uploader.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 152 matching lines @@
     // The upload range should start from the current first unreceived byte.
     EXPECT_EQ(received_bytes_, start_position);
     EXPECT_EQ(expected_upload_file_, local_file_path);
 
     // The upload data must be split into 512KB chunks.
     const int64_t expected_chunk_end =
         std::min(received_bytes_ + kUploadChunkSize, expected_content_length_);
     EXPECT_EQ(expected_chunk_end, end_position);
 
     // The upload URL returned by InitiateUpload() must be used.
-    EXPECT_TRUE(GURL(kTestUploadNewFileURL) == upload_location ||
-                GURL(kTestUploadExistingFileURL) == upload_location);
+    EXPECT_TRUE(upload_location == kTestUploadNewFileURL ||
+                upload_location == kTestUploadExistingFileURL);
 
     // Other parameters should be the exact values passed to DriveUploader.
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestMimeType, content_type);
 
     // Update the internal status of the current upload session.
     resume_upload_call_count_++;
     received_bytes_ = end_position;
 
     // Callback progress
     if (!progress_callback.is_null()) {
       // For the testing purpose, it always notifies the progress at the end of
       // each chunk uploading.
       int64_t chunk_size = end_position - start_position;
       base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
           base::Bind(progress_callback, chunk_size, chunk_size));
     }
 
     SendUploadRangeResponse(upload_location, callback);
     return CancelCallback();
   }
 
   // Handles a request to fetch the current upload status.
   CancelCallback GetUploadStatus(const GURL& upload_location,
                                  int64_t content_length,
                                  const UploadRangeCallback& callback) override {
     EXPECT_EQ(expected_content_length_, content_length);
     // The upload URL returned by InitiateUpload() must be used.
-    EXPECT_TRUE(GURL(kTestUploadNewFileURL) == upload_location ||
-                GURL(kTestUploadExistingFileURL) == upload_location);
+    EXPECT_TRUE(upload_location == kTestUploadNewFileURL ||
+                upload_location == kTestUploadExistingFileURL);
 
     SendUploadRangeResponse(upload_location, callback);
     return CancelCallback();
   }
 
   // Runs |callback| with the current upload status.
   void SendUploadRangeResponse(const GURL& upload_location,
                                const UploadRangeCallback& callback) {
     // Callback with response.
     UploadRangeResponse response;
     std::unique_ptr<FileResource> entry;
     if (received_bytes_ == expected_content_length_) {
       DriveApiErrorCode response_code =
-          upload_location == GURL(kTestUploadNewFileURL) ?
+          upload_location == kTestUploadNewFileURL ?
           HTTP_CREATED : HTTP_SUCCESS;
       response = UploadRangeResponse(response_code, -1, -1);
 
       entry.reset(new FileResource);
       entry->set_md5_checksum(kTestDummyMd5);
     } else {
       response = UploadRangeResponse(
           HTTP_RESUME_INCOMPLETE, 0, received_bytes_);
     }
     // ResumeUpload is an asynchronous function, so don't callback directly.
@@ skipping 722 matching lines @@
 
   EXPECT_EQ(HTTP_NOT_FOUND, results[0].error);
   EXPECT_TRUE(results[0].resume_url.is_empty());
   EXPECT_FALSE(results[0].file);
 
   EXPECT_EQ(HTTP_NOT_FOUND, results[1].error);
   EXPECT_TRUE(results[1].resume_url.is_empty());
   EXPECT_FALSE(results[1].file);
 }
 }  // namespace drive