Make GCMDriver::GetInstanceIDHandler protected, to avoid misuse

components/gcm_driver/gcm_driver_desktop_unittest.cc

 // Copyright 2014 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/gcm_driver/gcm_driver_desktop.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 1159 matching lines @@
   void GetInstanceIDDataCompleted(const std::string& instance_id,
                                   const std::string& extra_data);
   void GetToken(const std::string& app_id,
                 const std::string& authorized_entity,
                 const std::string& scope,
                 WaitToFinish wait_to_finish);
   void DeleteToken(const std::string& app_id,
                    const std::string& authorized_entity,
                    const std::string& scope,
                    WaitToFinish wait_to_finish);
+  void AddInstanceIDData(const std::string& app_id,
+                         const std::string& instance_id,
+                         const std::string& extra_data);
+  void RemoveInstanceIDData(const std::string& app_id);
 
   std::string instance_id() const { return instance_id_; }
   std::string extra_data() const { return extra_data_; }
 
  private:
   std::string instance_id_;
   std::string extra_data_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMDriverInstanceIDTest);
 };
 
 GCMDriverInstanceIDTest::GCMDriverInstanceIDTest() {
 }
 
 GCMDriverInstanceIDTest::~GCMDriverInstanceIDTest() {
 }
 
 void GCMDriverInstanceIDTest::GetReady() {
   CreateDriver();
   AddAppHandlers();
   PumpIOLoop();
   PumpUILoop();
 }
 
 void GCMDriverInstanceIDTest::GetInstanceID(const std::string& app_id,
                                             WaitToFinish wait_to_finish) {
   base::RunLoop run_loop;
   set_async_operation_completed_callback(run_loop.QuitClosure());
-  driver()->GetInstanceIDData(app_id,
-      base::Bind(&GCMDriverInstanceIDTest::GetInstanceIDDataCompleted,
-                 base::Unretained(this)));
+  driver()->GetInstanceIDHandlerInternal()->GetInstanceIDData(
+      app_id, base::Bind(&GCMDriverInstanceIDTest::GetInstanceIDDataCompleted,
+                         base::Unretained(this)));
   if (wait_to_finish == WAIT)
     run_loop.Run();
 }
 
 void GCMDriverInstanceIDTest::GetInstanceIDDataCompleted(
     const std::string& instance_id, const std::string& extra_data) {
   instance_id_ = instance_id;
   extra_data_ = extra_data;
   if (!async_operation_completed_callback().is_null())
     async_operation_completed_callback().Run();
 }
 
 void GCMDriverInstanceIDTest::GetToken(const std::string& app_id,
                                        const std::string& authorized_entity,
                                        const std::string& scope,
                                        WaitToFinish wait_to_finish) {
   base::RunLoop run_loop;
   set_async_operation_completed_callback(run_loop.QuitClosure());
   std::map<std::string, std::string> options;
-  driver()->GetToken(app_id,
-                     authorized_entity,
-                     scope,
-                     options,
-                     base::Bind(&GCMDriverTest::RegisterCompleted,
-                                base::Unretained(this)));
+  driver()->GetInstanceIDHandlerInternal()->GetToken(
+      app_id, authorized_entity, scope, options,
+      base::Bind(&GCMDriverTest::RegisterCompleted, base::Unretained(this)));
   if (wait_to_finish == WAIT)
     run_loop.Run();
 }
 
 void GCMDriverInstanceIDTest::DeleteToken(const std::string& app_id,
                                           const std::string& authorized_entity,
                                           const std::string& scope,
                                           WaitToFinish wait_to_finish) {
   base::RunLoop run_loop;
   set_async_operation_completed_callback(run_loop.QuitClosure());
-  driver()->DeleteToken(app_id,
-                        authorized_entity,
-                        scope,
-                        base::Bind(&GCMDriverTest::UnregisterCompleted,
-                                   base::Unretained(this)));
+  driver()->GetInstanceIDHandlerInternal()->DeleteToken(
+      app_id, authorized_entity, scope,
+      base::Bind(&GCMDriverTest::UnregisterCompleted, base::Unretained(this)));
   if (wait_to_finish == WAIT)
     run_loop.Run();
 }
 
+void GCMDriverInstanceIDTest::AddInstanceIDData(const std::string& app_id,
+                                                const std::string& instance_id,
+                                                const std::string& extra_data) {
+  driver()->GetInstanceIDHandlerInternal()->AddInstanceIDData(
+      app_id, instance_id, extra_data);
+}
+void GCMDriverInstanceIDTest::RemoveInstanceIDData(const std::string& app_id) {

[Peter Beverloo, 2016/03/10 21:11:23]

newline!!``oneone

[johnme, 2016/03/11 15:56:04]

Done.

+  driver()->GetInstanceIDHandlerInternal()->RemoveInstanceIDData(app_id);
+}
+
 TEST_F(GCMDriverInstanceIDTest, InstanceIDData) {
   GetReady();
 
-  driver()->AddInstanceIDData(kTestAppID1, kInstanceID1, "Foo");
+  AddInstanceIDData(kTestAppID1, kInstanceID1, "Foo");
   GetInstanceID(kTestAppID1, GCMDriverTest::WAIT);
 
   EXPECT_EQ(kInstanceID1, instance_id());
   EXPECT_EQ("Foo", extra_data());
 
-  driver()->RemoveInstanceIDData(kTestAppID1);
+  RemoveInstanceIDData(kTestAppID1);
   GetInstanceID(kTestAppID1, GCMDriverTest::WAIT);
 
   EXPECT_TRUE(instance_id().empty());
   EXPECT_TRUE(extra_data().empty());
 }
 
 TEST_F(GCMDriverInstanceIDTest, GCMClientNotReadyBeforeInstanceIDData) {
   CreateDriver();
   PumpIOLoop();
   PumpUILoop();
 
   // Make GCMClient not ready until PerformDelayedStart is called.
   GetGCMClient()->set_start_mode_overridding(
       FakeGCMClient::FORCE_TO_ALWAYS_DELAY_START_GCM);
 
   AddAppHandlers();
 
   // All operations are on hold until GCMClient is ready.
-  driver()->AddInstanceIDData(kTestAppID1, kInstanceID1, "Foo");
-  driver()->AddInstanceIDData(kTestAppID2, kInstanceID2, "Bar");
-  driver()->RemoveInstanceIDData(kTestAppID1);
+  AddInstanceIDData(kTestAppID1, kInstanceID1, "Foo");
+  AddInstanceIDData(kTestAppID2, kInstanceID2, "Bar");
+  RemoveInstanceIDData(kTestAppID1);
   GetInstanceID(kTestAppID2, GCMDriverTest::DO_NOT_WAIT);
   PumpIOLoop();
   PumpUILoop();
   EXPECT_TRUE(instance_id().empty());
   EXPECT_TRUE(extra_data().empty());
 
   // All operations will be performed after GCMClient becomes ready.
   GetGCMClient()->PerformDelayedStart();
   WaitForAsyncOperation();
   EXPECT_EQ(kInstanceID2, instance_id());
@@ skipping 76 matching lines @@
   PumpUILoop();
   EXPECT_EQ(GCMClient::UNKNOWN_ERROR, unregistration_result());
 
   // DeleteToken operation will be invoked after GCMClient becomes ready.
   GetGCMClient()->PerformDelayedStart();
   WaitForAsyncOperation();
   EXPECT_EQ(GCMClient::SUCCESS, unregistration_result());
 }
 
 }  // namespace gcm