Remove SyncSessionJob's location member

sync/engine/sync_session_job_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 "sync/engine/sync_session_job.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/time.h"
 #include "sync/internal_api/public/base/model_type_invalidation_map.h"
@@ skipping 91 matching lines @@
  private:
   scoped_ptr<sessions::SyncSessionContext> context_;
   std::vector<scoped_refptr<ModelSafeWorker> > workers_;
   MockDelegate delegate_;
   ModelSafeRoutingInfo routes_;
   bool config_params_callback_invoked_;
 };
 
 TEST_F(SyncSessionJobTest, Clone) {
   SyncSessionJob job1(SyncSessionJob::NUDGE, TimeTicks::Now(),
-      NewLocalSession().Pass(), ConfigurationParams(), FROM_HERE);
+      NewLocalSession().Pass(), ConfigurationParams());
 
   sessions::test_util::SimulateSuccess(job1.mutable_session(),
                                        job1.start_step(),
                                        job1.end_step());
   job1.Finish(false);
   ModelSafeRoutingInfo new_routes;
   new_routes[AUTOFILL] = GROUP_PASSIVE;
   context()->set_routing_info(new_routes);
-  const tracked_objects::Location from_here1(FROM_HERE);
   scoped_ptr<SyncSessionJob> clone1 = job1.Clone();
-  scoped_ptr<SyncSessionJob> clone1_loc = job1.CloneFromLocation(from_here1);
 
   ExpectClonesBase(&job1, clone1.get());
-  ExpectClonesBase(&job1, clone1_loc.get());
   EXPECT_NE(job1.session(), clone1->session());
-  EXPECT_EQ(job1.from_location().ToString(),
-            clone1->from_location().ToString());
-  EXPECT_NE(job1.session(), clone1_loc->session());
-  EXPECT_EQ(from_here1.ToString(), clone1_loc->from_location().ToString());
 
   context()->set_routing_info(routes());
   clone1->GrantCanaryPrivilege();
   sessions::test_util::SimulateSuccess(clone1->mutable_session(),
                                        clone1->start_step(),
                                        clone1->end_step());
   clone1->Finish(false);
-  const tracked_objects::Location from_here2(FROM_HERE);
   scoped_ptr<SyncSessionJob> clone2 = clone1->Clone();
-  scoped_ptr<SyncSessionJob> clone2_loc(clone1->CloneFromLocation(from_here2));
 
   ExpectClonesBase(clone1.get(), clone2.get());
-  ExpectClonesBase(clone1.get(), clone2_loc.get());
   EXPECT_NE(clone1->session(), clone2->session());
-  EXPECT_EQ(clone1->from_location().ToString(),
-            clone2->from_location().ToString());
   EXPECT_NE(clone1->session(), clone2->session());
-  EXPECT_EQ(from_here2.ToString(), clone2_loc->from_location().ToString());
 
   clone1.reset();
-  clone1_loc.reset();
   ExpectClonesBase(&job1, clone2.get());
   EXPECT_NE(job1.session(), clone2->session());
-  EXPECT_EQ(job1.from_location().ToString(),
-            clone2->from_location().ToString());
 }
 
 TEST_F(SyncSessionJobTest, CloneAfterEarlyExit) {
   SyncSessionJob job1(SyncSessionJob::NUDGE, TimeTicks::Now(),
-      NewLocalSession().Pass(), ConfigurationParams(), FROM_HERE);
+      NewLocalSession().Pass(), ConfigurationParams());
   job1.Finish(true);
   scoped_ptr<SyncSessionJob> job2 = job1.Clone();
-  scoped_ptr<SyncSessionJob> job2_loc = job1.CloneFromLocation(FROM_HERE);
   ExpectClonesBase(&job1, job2.get());
-  ExpectClonesBase(&job1, job2_loc.get());
 }
 
 TEST_F(SyncSessionJobTest, CloneAndAbandon) {
   scoped_ptr<SyncSession> session = NewLocalSession();
   SyncSession* session_ptr = session.get();
 
   SyncSessionJob job1(SyncSessionJob::NUDGE, TimeTicks::Now(),
-      session.Pass(), ConfigurationParams(), FROM_HERE);
+      session.Pass(), ConfigurationParams());
   ModelSafeRoutingInfo new_routes;
   new_routes[AUTOFILL] = GROUP_PASSIVE;
   context()->set_routing_info(new_routes);
 
   scoped_ptr<SyncSessionJob> clone1 = job1.CloneAndAbandon();
   ExpectClonesBase(&job1, clone1.get());
   EXPECT_FALSE(job1.session());
   EXPECT_EQ(session_ptr, clone1->session());
 }
 
 // Tests interaction between Finish and sync cycle success / failure.
 TEST_F(SyncSessionJobTest, Finish) {
   SyncSessionJob job1(SyncSessionJob::NUDGE, TimeTicks::Now(),
-      NewLocalSession().Pass(), ConfigurationParams(), FROM_HERE);
+      NewLocalSession().Pass(), ConfigurationParams());
 
   sessions::test_util::SimulateSuccess(job1.mutable_session(),
                                        job1.start_step(),
                                        job1.end_step());
   EXPECT_TRUE(job1.Finish(false /* early_exit */));
 
   scoped_ptr<SyncSessionJob> job2 = job1.Clone();
   sessions::test_util::SimulateConnectionFailure(job2->mutable_session(),
                                                  job2->start_step(),
                                                  job2->end_step());
   EXPECT_FALSE(job2->Finish(false));
 
   scoped_ptr<SyncSessionJob> job3 = job2->Clone();
   EXPECT_FALSE(job3->Finish(true));
 }
 
 TEST_F(SyncSessionJobTest, FinishCallsReadyTask) {
   ConfigurationParams params;
   params.ready_task = base::Bind(
       &SyncSessionJobTest::ConfigurationParamsCallback,
       base::Unretained(this));
 
   sessions::SyncSourceInfo info(
       sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
       ModelTypeInvalidationMap());
   scoped_ptr<SyncSession> session(
       new SyncSession(context(), delegate(), info));
 
   SyncSessionJob job1(SyncSessionJob::CONFIGURATION, TimeTicks::Now(),
-      session.Pass(), params, FROM_HERE);
+      session.Pass(), params);
   sessions::test_util::SimulateSuccess(job1.mutable_session(),
                                        job1.start_step(),
                                        job1.end_step());
   job1.Finish(false);
   EXPECT_TRUE(config_params_callback_invoked());
 }
 
 }  // namespace syncer