diff options
Diffstat (limited to 'components/gcm_driver/instance_id')
11 files changed, 313 insertions, 90 deletions
diff --git a/components/gcm_driver/instance_id/BUILD.gn b/components/gcm_driver/instance_id/BUILD.gn index 430de17..179828f 100644 --- a/components/gcm_driver/instance_id/BUILD.gn +++ b/components/gcm_driver/instance_id/BUILD.gn @@ -34,12 +34,13 @@ source_set("instance_id") { source_set("test_support") { testonly = true sources = [ - "fake_instance_id_driver.cc", - "fake_instance_id_driver.h", + "fake_gcm_driver_for_instance_id.cc", + "fake_gcm_driver_for_instance_id.h", ] deps = [ ":instance_id", + "//components/gcm_driver:test_support", "//testing/gtest", ] } diff --git a/components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.cc b/components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.cc new file mode 100644 index 0000000..2a50a03 --- /dev/null +++ b/components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.cc @@ -0,0 +1,45 @@ +// Copyright 2015 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/instance_id/fake_gcm_driver_for_instance_id.h" + +#include "base/bind.h" +#include "base/message_loop/message_loop.h" + +namespace instance_id { + +FakeGCMDriverForInstanceID::FakeGCMDriverForInstanceID() { +} + +FakeGCMDriverForInstanceID::~FakeGCMDriverForInstanceID() { +} + +gcm::InstanceIDStore* FakeGCMDriverForInstanceID::GetInstanceIDStore() { + return this; +} + +void FakeGCMDriverForInstanceID::AddInstanceIDData( + const std::string& app_id, + const std::string& instance_id_data) { + instance_id_data_[app_id] = instance_id_data; +} + +void FakeGCMDriverForInstanceID::RemoveInstanceIDData( + const std::string& app_id) { + instance_id_data_.erase(app_id); +} + +void FakeGCMDriverForInstanceID::GetInstanceIDData( + const std::string& app_id, + const gcm::InstanceIDStore::GetInstanceIDDataCallback& callback) { + std::string data; + auto iter = instance_id_data_.find(app_id); + if (iter != instance_id_data_.end()) + data = iter->second; + base::MessageLoop::current()->PostTask( + FROM_HERE, + base::Bind(callback, data)); +} + +} // namespace instance_id diff --git a/components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.h b/components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.h new file mode 100644 index 0000000..d5f9dd1 --- /dev/null +++ b/components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.h @@ -0,0 +1,42 @@ +// Copyright 2015 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. + +#ifndef COMPONENTS_GCM_DRIVER_INSTANCE_ID_FAKE_GCM_DRIVER__FOR_INSTANCE_ID_H_ +#define COMPONENTS_GCM_DRIVER_INSTANCE_ID_FAKE_GCM_DRIVER__FOR_INSTANCE_ID_H_ + +#include <map> +#include <string> + +#include "base/compiler_specific.h" +#include "base/macros.h" +#include "components/gcm_driver/fake_gcm_driver.h" + +namespace instance_id { + +class FakeGCMDriverForInstanceID : public gcm::FakeGCMDriver, + public gcm::InstanceIDStore { + public: + FakeGCMDriverForInstanceID(); + ~FakeGCMDriverForInstanceID() override; + + // FakeGCMDriver overrides: + gcm::InstanceIDStore* GetInstanceIDStore() override; + + // InstanceIDStore overrides: + void AddInstanceIDData(const std::string& app_id, + const std::string& instance_id_data) override; + void RemoveInstanceIDData(const std::string& app_id) override; + void GetInstanceIDData( + const std::string& app_id, + const gcm::InstanceIDStore::GetInstanceIDDataCallback& callback) override; + + private: + std::map<std::string, std::string> instance_id_data_; + + DISALLOW_COPY_AND_ASSIGN(FakeGCMDriverForInstanceID); +}; + +} // namespace instance_id + +#endif // COMPONENTS_GCM_DRIVER_INSTANCE_ID_FAKE_GCM_DRIVER__FOR_INSTANCE_ID_H_ diff --git a/components/gcm_driver/instance_id/fake_instance_id_driver.cc b/components/gcm_driver/instance_id/fake_instance_id_driver.cc deleted file mode 100644 index 6b88f22..0000000 --- a/components/gcm_driver/instance_id/fake_instance_id_driver.cc +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright 2015 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/instance_id/fake_instance_id_driver.h" - -namespace instance_id { - -FakeInstanceIDDriver::FakeInstanceIDDriver() - : InstanceIDDriver(NULL) { -} - -FakeInstanceIDDriver::~FakeInstanceIDDriver() { -} - -} // namespace instance_id diff --git a/components/gcm_driver/instance_id/fake_instance_id_driver.h b/components/gcm_driver/instance_id/fake_instance_id_driver.h deleted file mode 100644 index 60fc0b2..0000000 --- a/components/gcm_driver/instance_id/fake_instance_id_driver.h +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright 2015 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. - -#ifndef COMPONENTS_GCM_DRIVER_INSTANCE_ID_FAKE_INSTANCE_ID_DRIVER_H_ -#define COMPONENTS_GCM_DRIVER_INSTANCE_ID_FAKE_INSTANCE_ID_DRIVER_H_ - -#include "base/compiler_specific.h" -#include "base/macros.h" -#include "components/gcm_driver/instance_id/instance_id_driver.h" - -namespace instance_id { - -class InstanceID; - -class FakeInstanceIDDriver : public InstanceIDDriver { - public: - FakeInstanceIDDriver(); - ~FakeInstanceIDDriver() override; - - private: - DISALLOW_COPY_AND_ASSIGN(FakeInstanceIDDriver); -}; - -} // namespace instance_id - -#endif // COMPONENTS_GCM_DRIVER_INSTANCE_ID_FAKE_INSTANCE_ID_DRIVER_H_ diff --git a/components/gcm_driver/instance_id/instance_id.h b/components/gcm_driver/instance_id/instance_id.h index 731d274..8141a3a 100644 --- a/components/gcm_driver/instance_id/instance_id.h +++ b/components/gcm_driver/instance_id/instance_id.h @@ -41,6 +41,9 @@ class InstanceID { // Asynchronous callbacks. typedef base::Callback<void(const std::string& app_id, bool update_id)> TokenRefreshCallback; + typedef base::Callback<void(const std::string& id)> GetIDCallback; + typedef base::Callback<void(const base::Time& creation_time)> + GetCreationTimeCallback; typedef base::Callback<void(const std::string& token, Result result)> GetTokenCallback; typedef base::Callback<void(Result result)> DeleteTokenCallback; @@ -62,10 +65,10 @@ class InstanceID { void SetTokenRefreshCallback(const TokenRefreshCallback& callback); // Returns the Instance ID. - virtual std::string GetID() = 0; + virtual void GetID(const GetIDCallback& callback) = 0; // Returns the time when the InstanceID has been generated. - virtual base::Time GetCreationTime() = 0; + virtual void GetCreationTime(const GetCreationTimeCallback& callback) = 0; // Retrieves a token that allows the authorized entity to access the service // defined as "scope". diff --git a/components/gcm_driver/instance_id/instance_id_android.cc b/components/gcm_driver/instance_id/instance_id_android.cc index 2057a814..9e7a164 100644 --- a/components/gcm_driver/instance_id/instance_id_android.cc +++ b/components/gcm_driver/instance_id/instance_id_android.cc @@ -21,14 +21,13 @@ InstanceIDAndroid::InstanceIDAndroid(const std::string& app_id) InstanceIDAndroid::~InstanceIDAndroid() { } -std::string InstanceIDAndroid::GetID() { +void InstanceIDAndroid::GetID(const GetIDCallback& callback) { NOTIMPLEMENTED(); - return std::string(); } -base::Time InstanceIDAndroid::GetCreationTime() { +void InstanceIDAndroid::GetCreationTime( + const GetCreationTimeCallback& callback) { NOTIMPLEMENTED(); - return base::Time(); } void InstanceIDAndroid::GetToken( diff --git a/components/gcm_driver/instance_id/instance_id_android.h b/components/gcm_driver/instance_id/instance_id_android.h index b09901a..7a6babf 100644 --- a/components/gcm_driver/instance_id/instance_id_android.h +++ b/components/gcm_driver/instance_id/instance_id_android.h @@ -19,12 +19,12 @@ namespace instance_id { // InstanceID implementation for Android. class InstanceIDAndroid : public InstanceID { public: - explicit InstanceIDAndroid(const std::string& app_id); + InstanceIDAndroid(const std::string& app_id); ~InstanceIDAndroid() override; // InstanceID: - std::string GetID() override; - base::Time GetCreationTime() override; + void GetID(const GetIDCallback& callback) override; + void GetCreationTime(const GetCreationTimeCallback& callback) override; void GetToken(const std::string& audience, const std::string& scope, const std::map<std::string, std::string>& options, diff --git a/components/gcm_driver/instance_id/instance_id_driver_unittest.cc b/components/gcm_driver/instance_id/instance_id_driver_unittest.cc index 37a1040..41305b5 100644 --- a/components/gcm_driver/instance_id/instance_id_driver_unittest.cc +++ b/components/gcm_driver/instance_id/instance_id_driver_unittest.cc @@ -9,7 +9,7 @@ #include "base/message_loop/message_loop.h" #include "base/run_loop.h" #include "base/strings/string_util.h" -#include "components/gcm_driver/fake_gcm_driver.h" +#include "components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.h" #include "components/gcm_driver/instance_id/instance_id.h" #include "testing/gtest/include/gtest/gtest.h" @@ -46,41 +46,107 @@ class InstanceIDDriverTest : public testing::Test { void WaitForAsyncOperation(); - void DeleteIDCompleted(InstanceID::Result result); + // Recreates InstanceIDDriver to simulate restart. + void RecreateInstanceIDDriver(); + + // Sync wrappers for async version. + std::string GetID(InstanceID* instance_id); + base::Time GetCreationTime(InstanceID* instance_id); + InstanceID::Result DeleteID(InstanceID* instance_id); InstanceIDDriver* driver() const { return driver_.get(); } - InstanceID::Result delete_id_result() const { return delete_id_result_; } private: + void GetIDCompleted(const std::string& id); + void GetCreationTimeCompleted(const base::Time& creation_time); + void DeleteIDCompleted(InstanceID::Result result); + base::MessageLoopForUI message_loop_; - scoped_ptr<gcm::FakeGCMDriver> gcm_driver_; + scoped_ptr<FakeGCMDriverForInstanceID> gcm_driver_; scoped_ptr<InstanceIDDriver> driver_; - InstanceID::Result delete_id_result_; + + std::string id_; + base::Time creation_time_; + InstanceID::Result result_; + + bool async_operation_completed_; base::Closure async_operation_completed_callback_; DISALLOW_COPY_AND_ASSIGN(InstanceIDDriverTest); }; InstanceIDDriverTest::InstanceIDDriverTest() - : delete_id_result_(InstanceID::UNKNOWN_ERROR) { + : result_(InstanceID::UNKNOWN_ERROR), + async_operation_completed_(false) { } InstanceIDDriverTest::~InstanceIDDriverTest() { } void InstanceIDDriverTest::SetUp() { - gcm_driver_.reset(new gcm::FakeGCMDriver); + gcm_driver_.reset(new FakeGCMDriverForInstanceID); + RecreateInstanceIDDriver(); +} + +void InstanceIDDriverTest::RecreateInstanceIDDriver() { driver_.reset(new InstanceIDDriver(gcm_driver_.get())); } void InstanceIDDriverTest::WaitForAsyncOperation() { + // No need to wait if async operation is not needed. + if (async_operation_completed_) + return; base::RunLoop run_loop; async_operation_completed_callback_ = run_loop.QuitClosure(); run_loop.Run(); } +std::string InstanceIDDriverTest::GetID(InstanceID* instance_id) { + async_operation_completed_ = false; + id_.clear(); + instance_id->GetID(base::Bind(&InstanceIDDriverTest::GetIDCompleted, + base::Unretained(this))); + WaitForAsyncOperation(); + return id_; +} + +base::Time InstanceIDDriverTest::GetCreationTime(InstanceID* instance_id) { + async_operation_completed_ = false; + creation_time_ = base::Time(); + instance_id->GetCreationTime( + base::Bind(&InstanceIDDriverTest::GetCreationTimeCompleted, + base::Unretained(this))); + WaitForAsyncOperation(); + return creation_time_; +} + +InstanceID::Result InstanceIDDriverTest::DeleteID(InstanceID* instance_id) { + async_operation_completed_ = false; + result_ = InstanceID::UNKNOWN_ERROR;; + instance_id->DeleteID(base::Bind(&InstanceIDDriverTest::DeleteIDCompleted, + base::Unretained(this))); + WaitForAsyncOperation(); + return result_; +} + +void InstanceIDDriverTest::GetIDCompleted(const std::string& id) { + async_operation_completed_ = true; + id_ = id; + if (!async_operation_completed_callback_.is_null()) + async_operation_completed_callback_.Run(); +} + +void InstanceIDDriverTest::GetCreationTimeCompleted( + const base::Time& creation_time) { + async_operation_completed_ = true; + creation_time_ = creation_time; + if (!async_operation_completed_callback_.is_null()) + async_operation_completed_callback_.Run(); +} + void InstanceIDDriverTest::DeleteIDCompleted(InstanceID::Result result) { - delete_id_result_ = result; + async_operation_completed_ = true; + result_ = result; if (!async_operation_completed_callback_.is_null()) async_operation_completed_callback_.Run(); } @@ -88,45 +154,70 @@ void InstanceIDDriverTest::DeleteIDCompleted(InstanceID::Result result) { TEST_F(InstanceIDDriverTest, NewID) { // Creation time should not be set when the ID is not created. InstanceID* instance_id1 = driver()->GetInstanceID(kTestAppID1); - EXPECT_TRUE(instance_id1->GetCreationTime().is_null()); + EXPECT_TRUE(GetCreationTime(instance_id1).is_null()); // New ID is generated for the first time. - std::string id1 = instance_id1->GetID(); - EXPECT_FALSE(id1.empty()); + std::string id1 = GetID(instance_id1); EXPECT_TRUE(VerifyInstanceID(id1)); - base::Time creation_time = instance_id1->GetCreationTime(); + base::Time creation_time = GetCreationTime(instance_id1); EXPECT_FALSE(creation_time.is_null()); // Same ID is returned for the same app. - EXPECT_EQ(id1, instance_id1->GetID()); - EXPECT_EQ(creation_time, instance_id1->GetCreationTime()); + EXPECT_EQ(id1, GetID(instance_id1)); + EXPECT_EQ(creation_time, GetCreationTime(instance_id1)); // New ID is generated for another app. InstanceID* instance_id2 = driver()->GetInstanceID(kTestAppID2); - std::string id2 = instance_id2->GetID(); - EXPECT_FALSE(id2.empty()); + std::string id2 = GetID(instance_id2); EXPECT_TRUE(VerifyInstanceID(id2)); EXPECT_NE(id1, id2); - EXPECT_FALSE(instance_id2->GetCreationTime().is_null()); + EXPECT_FALSE(GetCreationTime(instance_id2).is_null()); +} + +TEST_F(InstanceIDDriverTest, PersistID) { + InstanceID* instance_id = driver()->GetInstanceID(kTestAppID1); + + // Create the ID for the first time. The ID and creation time should be saved + // to the store. + std::string id = GetID(instance_id); + EXPECT_FALSE(id.empty()); + base::Time creation_time = GetCreationTime(instance_id); + EXPECT_FALSE(creation_time.is_null()); + + // Simulate restart by recreating InstanceIDDriver. Same ID and creation time + // should be expected. + RecreateInstanceIDDriver(); + instance_id = driver()->GetInstanceID(kTestAppID1); + EXPECT_EQ(creation_time, GetCreationTime(instance_id)); + EXPECT_EQ(id, GetID(instance_id)); + + // Delete the ID. The ID and creation time should be removed from the store. + EXPECT_EQ(InstanceID::SUCCESS, DeleteID(instance_id)); + EXPECT_TRUE(GetCreationTime(instance_id).is_null()); + + // Simulate restart by recreating InstanceIDDriver. Different ID should be + // expected. + // Note that we do not check for different creation time since the test might + // be run at a very fast server. + RecreateInstanceIDDriver(); + instance_id = driver()->GetInstanceID(kTestAppID1); + EXPECT_NE(id, GetID(instance_id)); } TEST_F(InstanceIDDriverTest, DeleteID) { InstanceID* instance_id = driver()->GetInstanceID(kTestAppID1); - std::string id1 = instance_id->GetID(); + std::string id1 = GetID(instance_id); EXPECT_FALSE(id1.empty()); - EXPECT_FALSE(instance_id->GetCreationTime().is_null()); + EXPECT_FALSE(GetCreationTime(instance_id).is_null()); // New ID will be generated from GetID after calling DeleteID. - instance_id->DeleteID(base::Bind(&InstanceIDDriverTest::DeleteIDCompleted, - base::Unretained(this))); - WaitForAsyncOperation(); - EXPECT_EQ(InstanceID::SUCCESS, delete_id_result()); - EXPECT_TRUE(instance_id->GetCreationTime().is_null()); + EXPECT_EQ(InstanceID::SUCCESS, DeleteID(instance_id)); + EXPECT_TRUE(GetCreationTime(instance_id).is_null()); - std::string id2 = instance_id->GetID(); + std::string id2 = GetID(instance_id); EXPECT_FALSE(id2.empty()); EXPECT_NE(id1, id2); - EXPECT_FALSE(instance_id->GetCreationTime().is_null()); + EXPECT_FALSE(GetCreationTime(instance_id).is_null()); } } // instance_id diff --git a/components/gcm_driver/instance_id/instance_id_impl.cc b/components/gcm_driver/instance_id/instance_id_impl.cc index 0ebcdf8..b77cf3f 100644 --- a/components/gcm_driver/instance_id/instance_id_impl.cc +++ b/components/gcm_driver/instance_id/instance_id_impl.cc @@ -9,6 +9,7 @@ #include "base/bind.h" #include "base/logging.h" #include "base/message_loop/message_loop.h" +#include "base/strings/string_number_conversions.h" #include "components/gcm_driver/gcm_driver_desktop.h" #include "crypto/random.h" @@ -23,19 +24,50 @@ InstanceID* InstanceID::Create(const std::string& app_id, InstanceIDImpl::InstanceIDImpl(const std::string& app_id, gcm::GCMDriver* gcm_driver) : InstanceID(app_id), - gcm_driver_(gcm_driver) { + gcm_driver_(gcm_driver), + load_from_store_(false), + weak_ptr_factory_(this) { + gcm_driver_->GetInstanceIDStore()->GetInstanceIDData( + app_id, + base::Bind(&InstanceIDImpl::GetInstanceIDDataCompleted, + weak_ptr_factory_.GetWeakPtr())); } InstanceIDImpl::~InstanceIDImpl() { } -std::string InstanceIDImpl::GetID() { +void InstanceIDImpl::GetID(const GetIDCallback& callback) { + if (!delayed_task_controller_.CanRunTaskWithoutDelay()) { + delayed_task_controller_.AddTask( + base::Bind(&InstanceIDImpl::DoGetID, + weak_ptr_factory_.GetWeakPtr(), + callback)); + return; + } + + DoGetID(callback); +} + +void InstanceIDImpl::DoGetID(const GetIDCallback& callback) { EnsureIDGenerated(); - return id_; + callback.Run(id_); +} + +void InstanceIDImpl::GetCreationTime(const GetCreationTimeCallback& callback) { + if (!delayed_task_controller_.CanRunTaskWithoutDelay()) { + delayed_task_controller_.AddTask( + base::Bind(&InstanceIDImpl::DoGetCreationTime, + weak_ptr_factory_.GetWeakPtr(), + callback)); + return; + } + + DoGetCreationTime(callback); } -base::Time InstanceIDImpl::GetCreationTime() { - return creation_time_; +void InstanceIDImpl::DoGetCreationTime( + const GetCreationTimeCallback& callback) { + callback.Run(creation_time_); } void InstanceIDImpl::GetToken( @@ -53,7 +85,8 @@ void InstanceIDImpl::DeleteToken(const std::string& authorized_entity, } void InstanceIDImpl::DeleteID(const DeleteIDCallback& callback) { - // TODO(jianli): Delete the ID from the store. + gcm_driver_->GetInstanceIDStore()->RemoveInstanceIDData(app_id()); + id_.clear(); creation_time_ = base::Time(); @@ -62,6 +95,12 @@ void InstanceIDImpl::DeleteID(const DeleteIDCallback& callback) { base::Bind(callback, InstanceID::SUCCESS)); } +void InstanceIDImpl::GetInstanceIDDataCompleted( + const std::string& instance_id_data) { + Deserialize(instance_id_data); + delayed_task_controller_.SetReady(); +} + void InstanceIDImpl::EnsureIDGenerated() { if (!id_.empty()) return; @@ -91,7 +130,36 @@ void InstanceIDImpl::EnsureIDGenerated() { creation_time_ = base::Time::Now(); - // TODO(jianli): Save the ID to the store. + // Save to the persistent store. + gcm_driver_->GetInstanceIDStore()->AddInstanceIDData( + app_id(), SerializeAsString()); +} + +std::string InstanceIDImpl::SerializeAsString() const { + std::string serialized_data; + serialized_data += id_; + serialized_data += ","; + serialized_data += base::Int64ToString(creation_time_.ToInternalValue()); + return serialized_data; +} + +void InstanceIDImpl::Deserialize(const std::string& serialized_data) { + if (serialized_data.empty()) + return; + std::size_t pos = serialized_data.find(','); + if (pos == std::string::npos) { + DVLOG(1) << "Failed to deserialize the InstanceID data: " + serialized_data; + return; + } + + id_ = serialized_data.substr(0, pos); + + int64 time_internal = 0LL; + if (!base::StringToInt64(serialized_data.substr(pos + 1), &time_internal)) { + DVLOG(1) << "Failed to deserialize the InstanceID data: " + serialized_data; + return; + } + creation_time_ = base::Time::FromInternalValue(time_internal); } } // namespace instance_id diff --git a/components/gcm_driver/instance_id/instance_id_impl.h b/components/gcm_driver/instance_id/instance_id_impl.h index dd7b775..a5124c1 100644 --- a/components/gcm_driver/instance_id/instance_id_impl.h +++ b/components/gcm_driver/instance_id/instance_id_impl.h @@ -11,7 +11,9 @@ #include "base/callback.h" #include "base/macros.h" #include "base/memory/scoped_ptr.h" +#include "base/memory/weak_ptr.h" #include "base/time/time.h" +#include "components/gcm_driver/gcm_delayed_task_controller.h" #include "components/gcm_driver/instance_id/instance_id.h" namespace gcm { @@ -27,8 +29,8 @@ class InstanceIDImpl : public InstanceID { ~InstanceIDImpl() override; // InstanceID: - std::string GetID() override; - base::Time GetCreationTime() override; + void GetID(const GetIDCallback& callback) override; + void GetCreationTime(const GetCreationTimeCallback& callback) override; void GetToken(const std::string& authorized_entity, const std::string& scope, const std::map<std::string, std::string>& options, @@ -39,9 +41,22 @@ class InstanceIDImpl : public InstanceID { void DeleteID(const DeleteIDCallback& callback) override; private: + void EnsureIDGenerated(); + void GetInstanceIDDataCompleted(const std::string& instance_id_data); + + void DoGetID(const GetIDCallback& callback); + void DoGetCreationTime(const GetCreationTimeCallback& callback); + + // Encodes/decodes the InstanceID data to work with the persistent store. + std::string SerializeAsString() const; + void Deserialize(const std::string& serialized_data); + gcm::GCMDriver* gcm_driver_; // Not owned. - void EnsureIDGenerated(); + gcm::GCMDelayedTaskController delayed_task_controller_; + + // Flag to indicate that we have tries to load the data from the store. + bool load_from_store_; // The generated Instance ID. std::string id_; @@ -49,6 +64,8 @@ class InstanceIDImpl : public InstanceID { // The time when the Instance ID has been generated. base::Time creation_time_; + base::WeakPtrFactory<InstanceIDImpl> weak_ptr_factory_; + DISALLOW_COPY_AND_ASSIGN(InstanceIDImpl); }; |