Fix crash when syncing files on Drive.

chrome/browser/chromeos/drive/sync/entry_update_performer.cc

 // Copyright 2013 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 "chrome/browser/chromeos/drive/sync/entry_update_performer.h"
 
 #include <set>
 
 #include "base/callback_helpers.h"
 #include "base/files/file_util.h"
@@ skipping 236 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void EntryUpdatePerformer::UpdateEntry(const std::string& local_id,
                                        const ClientContext& context,
                                        const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scoped_ptr<LocalState> local_state(new LocalState);
-  LocalState* local_state_ptr = local_state.get();
+  LocalState* const local_state_ptr = local_state.get();
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&PrepareUpdate, metadata_, cache_, local_id, local_state_ptr),
       base::Bind(&EntryUpdatePerformer::UpdateEntryAfterPrepare,
                  weak_ptr_factory_.GetWeakPtr(), context, callback,
                  base::Passed(&local_state)));
 }
 
 void EntryUpdatePerformer::UpdateEntryAfterPrepare(
@@ skipping 52 matching lines @@
     if (local_state->entry.resource_id().empty()) {
       // Not locking the loader intentionally here to avoid making the UI
       // unresponsive while uploading large files.
       // FinishUpdate() is responsible to resolve conflicts caused by this.
       scoped_ptr<base::ScopedClosureRunner> null_loader_lock;
 
       DriveUploader::UploadNewFileOptions options;
       options.modified_date = last_modified;
       options.last_viewed_by_me_date = last_accessed;
       options.properties = properties;
+      LocalState* const local_state_ptr = local_state.get();
       scheduler_->UploadNewFile(
-          local_state->parent_entry.resource_id(), local_state->drive_file_path,
-          local_state->cache_file_path, local_state->entry.title(),
-          local_state->entry.file_specific_info().content_mime_type(), options,
-          context,
+          local_state_ptr->parent_entry.resource_id(),
+          local_state_ptr->drive_file_path, local_state_ptr->cache_file_path,
+          local_state_ptr->entry.title(),
+          local_state_ptr->entry.file_specific_info().content_mime_type(),
+          options, context,
           base::Bind(&EntryUpdatePerformer::UpdateEntryAfterUpdateResource,
                      weak_ptr_factory_.GetWeakPtr(), context, callback,
                      base::Passed(&local_state),
                      base::Passed(&null_loader_lock)));
     } else {
       DriveUploader::UploadExistingFileOptions options;
       options.title = local_state->entry.title();
       options.parent_resource_id = local_state->parent_entry.resource_id();
       options.modified_date = last_modified;
       options.last_viewed_by_me_date = last_accessed;
       options.properties = properties;
+      LocalState* const local_state_ptr = local_state.get();
       scheduler_->UploadExistingFile(
-          local_state->entry.resource_id(), local_state->drive_file_path,
-          local_state->cache_file_path,
-          local_state->entry.file_specific_info().content_mime_type(), options,
-          context,
+          local_state_ptr->entry.resource_id(),
+          local_state_ptr->drive_file_path, local_state_ptr->cache_file_path,
+          local_state_ptr->entry.file_specific_info().content_mime_type(),
+          options, context,
           base::Bind(&EntryUpdatePerformer::UpdateEntryAfterUpdateResource,
                      weak_ptr_factory_.GetWeakPtr(), context, callback,
                      base::Passed(&local_state),
                      base::Passed(scoped_ptr<base::ScopedClosureRunner>())));
     }
     return;
   }
 
   // Create directory.
   if (local_state->entry.file_info().is_directory() &&
       local_state->entry.resource_id().empty()) {
     // Lock the loader to avoid race conditions.
     scoped_ptr<base::ScopedClosureRunner> loader_lock =
         loader_controller_->GetLock();
 
     DriveServiceInterface::AddNewDirectoryOptions options;
     options.modified_date = last_modified;
     options.last_viewed_by_me_date = last_accessed;
     options.properties = properties;
+    LocalState* const local_state_ptr = local_state.get();
     scheduler_->AddNewDirectory(
-        local_state->parent_entry.resource_id(), local_state->entry.title(),
-        options, context,
+        local_state_ptr->parent_entry.resource_id(),
+        local_state_ptr->entry.title(), options, context,
         base::Bind(&EntryUpdatePerformer::UpdateEntryAfterUpdateResource,
                    weak_ptr_factory_.GetWeakPtr(), context, callback,
                    base::Passed(&local_state), base::Passed(&loader_lock)));
     return;
   }
 
   // No need to perform update.
   if (local_state->entry.metadata_edit_state() == ResourceEntry::CLEAN ||
       local_state->entry.resource_id().empty()) {
     callback.Run(FILE_ERROR_OK);
     return;
   }
 
   // Perform metadata update.
+  LocalState* const local_state_ptr = local_state.get();
   scheduler_->UpdateResource(
-      local_state->entry.resource_id(), local_state->parent_entry.resource_id(),
-      local_state->entry.title(), last_modified, last_accessed, properties,
+      local_state_ptr->entry.resource_id(),
+      local_state_ptr->parent_entry.resource_id(),
+      local_state_ptr->entry.title(), last_modified, last_accessed, properties,
       context,
       base::Bind(&EntryUpdatePerformer::UpdateEntryAfterUpdateResource,
                  weak_ptr_factory_.GetWeakPtr(), context, callback,
                  base::Passed(&local_state),
                  base::Passed(scoped_ptr<base::ScopedClosureRunner>())));
 }
 
 void EntryUpdatePerformer::UpdateEntryAfterUpdateResource(
     const ClientContext& context,
     const FileOperationCallback& callback,
@@ skipping 33 matching lines @@
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   delegate_->OnFileChangedByOperation(*changed_files);
   callback.Run(error);
 }
 
 }  // namespace internal
 }  // namespace drive