Remove SyncSessionJob's location member

sync/engine/sync_session_job.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 "sync/internal_api/public/sessions/model_neutral_state.h"
 
 namespace syncer {
 
 SyncSessionJob::~SyncSessionJob() {
   if (destruction_observer_)
     destruction_observer_->OnJobDestroyed(this);
 }
 
 SyncSessionJob::SyncSessionJob(
     Purpose purpose,
     base::TimeTicks start,
     scoped_ptr<sessions::SyncSession> session,
-    const ConfigurationParams& config_params,
-    const tracked_objects::Location& from_location)
+    const ConfigurationParams& config_params)
     : purpose_(purpose),
       scheduled_start_(start),
       session_(session.Pass()),
       is_canary_(false),
       config_params_(config_params),
-      finished_(NOT_FINISHED),
-      from_location_(from_location) {
+      finished_(NOT_FINISHED) {
 }
 
 void SyncSessionJob::set_destruction_observer(
     const base::WeakPtr<DestructionObserver>& destruction_observer) {
   destruction_observer_ = destruction_observer;
 }
 
 #define ENUM_CASE(x) case x: return #x; break;
 const char* SyncSessionJob::GetPurposeString(SyncSessionJob::Purpose purpose) {
   switch (purpose) {
@@ skipping 45 matching lines @@
   if (!config_params_.ready_task.is_null())
     config_params_.ready_task.Run();
   return true;
 }
 
 scoped_ptr<SyncSessionJob> SyncSessionJob::CloneAndAbandon() {
   DCHECK_EQ(finished_, NOT_FINISHED);
   // Clone |this|, and abandon it by NULL-ing session_.
   return scoped_ptr<SyncSessionJob> (new SyncSessionJob(
       purpose_, scheduled_start_, session_.Pass(),
-      config_params_, from_location_));
+      config_params_));
 }
 
 scoped_ptr<SyncSessionJob> SyncSessionJob::Clone() const {
   DCHECK_GT(finished_, NOT_FINISHED);
   return scoped_ptr<SyncSessionJob>(new SyncSessionJob(
       purpose_, scheduled_start_, CloneSession().Pass(),
-      config_params_, from_location_));
-}
-
-scoped_ptr<SyncSessionJob> SyncSessionJob::CloneFromLocation(
-    const tracked_objects::Location& from_here) const {
-  DCHECK_GT(finished_, NOT_FINISHED);
-  return scoped_ptr<SyncSessionJob>(new SyncSessionJob(
-      purpose_, scheduled_start_, CloneSession().Pass(),
-      config_params_, from_here));
+      config_params_));
 }
 
 scoped_ptr<sessions::SyncSession> SyncSessionJob::CloneSession() const {
   return scoped_ptr<sessions::SyncSession>(
       new sessions::SyncSession(session_->context(),
           session_->delegate(), session_->source()));
 }
 
 bool SyncSessionJob::is_canary() const {
   return is_canary_;
@@ skipping 12 matching lines @@
 };
 
 const sessions::SyncSession* SyncSessionJob::session() const {
   return session_.get();
 }
 
 sessions::SyncSession* SyncSessionJob::mutable_session() {
   return session_.get();
 }
 
-const tracked_objects::Location& SyncSessionJob::from_location() const {
-  return from_location_;
-}
-
 ConfigurationParams SyncSessionJob::config_params() const {
   return config_params_;
 }
 
 void SyncSessionJob::GrantCanaryPrivilege() {
   DCHECK_EQ(finished_, NOT_FINISHED);
   DVLOG(2) << "Granting canary priviliege to " << session_.get();
   is_canary_ = true;
 }
 
@@ skipping 25 matching lines @@
       return;
     default:
       NOTREACHED();
       *start = SYNCER_END;
       *end = SYNCER_END;
       return;
   }
 }
 
 }  // namespace syncer