Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/gdata_operations_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 "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/gdata/gdata_operations.h"
 #include "chrome/browser/chromeos/gdata/gdata_test_util.h"
 #include "chrome/browser/chromeos/gdata/operation_runner.h"
@@ skipping 31 matching lines @@
  protected:
   // GetDataOperation overrides:
   virtual GURL GetURL() const OVERRIDE {
     // This method is never called because this test does not fetch json from
     // network.
     NOTREACHED();
     return GURL();
   }
 };
 
-void GetDataOperationParseJsonCallback(GDataErrorCode* error_out,
+void GetDataOperationParseJsonCallback(DriveErrorCode* error_out,
                                        scoped_ptr<base::Value>* value_out,
-                                       GDataErrorCode error_in,
+                                       DriveErrorCode error_in,
                                        scoped_ptr<base::Value> value_in) {
   value_out->swap(value_in);
   *error_out = error_in;
 }
 
 }  // namespace
 
 class GDataOperationsTest : public testing::Test {
  protected:
   GDataOperationsTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_) {
   }
 
   virtual void SetUp() OVERRIDE {
     profile_.reset(new TestingProfile);
     runner_.reset(new OperationRunner(profile_.get()));
     runner_->Initialize();
   }
 
  protected:
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<OperationRunner> runner_;
 };
 
 TEST_F(GDataOperationsTest, GetDataOperationParseJson) {
   scoped_ptr<base::Value> value;
-  GDataErrorCode error;
+  DriveErrorCode error;
   gdata::GetDataCallback cb = base::Bind(&GetDataOperationParseJsonCallback,
                                          &error,
                                          &value);
   JsonParseTestGetDataOperation* getData =
       new JsonParseTestGetDataOperation(runner_->operation_registry(), cb);
   getData->NotifyStart();
 
   // Parses a valid json string.
   {
     std::string valid_json_str =
@@ skipping 48 matching lines @@
     EXPECT_EQ("cow", s);
     EXPECT_TRUE(list_values[0]->GetAsString(&s));
     EXPECT_EQ("a", s);
     EXPECT_TRUE(list_values[1]->GetAsString(&s));
     EXPECT_EQ("b", s);
   }
 }
 
 TEST_F(GDataOperationsTest, GetDataOperationParseInvalidJson) {
   scoped_ptr<base::Value> value;
-  GDataErrorCode error;
+  DriveErrorCode error;
   gdata::GetDataCallback cb = base::Bind(&GetDataOperationParseJsonCallback,
                                          &error,
                                          &value);
   JsonParseTestGetDataOperation* getData =
       new JsonParseTestGetDataOperation(runner_->operation_registry(), cb);
   getData->NotifyStart();
 
   // Parses an invalid json string.
   {
     std::string invalid_json_str =
         "/* hogehoge *"
         "  \"test\": {"
         "    \"moo\": \"cow"
         "  "
         "  \"list\": ["
         "    \"foo\","
         "    \"bar\""
         "  ]";
 
     getData->ParseResponse(HTTP_SUCCESS, invalid_json_str);
     test_util::RunBlockingPoolTask();
 
-    EXPECT_EQ(GDATA_PARSE_ERROR, error);
+    EXPECT_EQ(DRIVE_PARSE_ERROR, error);
     ASSERT_TRUE(value.get() == NULL);
   }
 }
 
 }  // namespace gdata