Remove calls to IsRunningSequenceOnCurrentThread() from log_private_api_chromeos.cc

chrome/browser/extensions/api/log_private/log_private_api_chromeos.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/extensions/api/log_private/log_private_api.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 43 matching lines @@
 const int kNetLogEventDelayMilliseconds = 100;
 
 // Gets sequenced task runner for file specific calls within this API.
 scoped_refptr<base::SequencedTaskRunner> GetSequencedTaskRunner() {
   base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   return pool->GetSequencedTaskRunnerWithShutdownBehavior(
       pool->GetNamedSequenceToken(FileResource::kSequenceToken),
       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 }
 
+#if DCHECK_IS_ON()
+base::LazyInstance<base::SequenceChecker>::Leaky
+    g_file_resource_sequence_checker = LAZY_INSTANCE_INITIALIZER;
+#endif
+
 // Checks if we are running on sequenced task runner thread.
-bool IsRunningOnSequenceThread() {
-  base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
-  return pool->IsRunningSequenceOnCurrentThread(
-      pool->GetNamedSequenceToken(FileResource::kSequenceToken));
+void AssertCurrentlyOnFileResourceSequence() {
+#if DCHECK_IS_ON()
+  DCHECK(g_file_resource_sequence_checker.Get().CalledOnValidSequence());
+#endif
 }
 
 std::unique_ptr<LogParser> CreateLogParser(const std::string& log_type) {
   if (log_type == "syslog")
     return std::unique_ptr<LogParser>(new SyslogParser());
   // TODO(shinfan): Add more parser here
 
   NOTREACHED() << "Invalid log type: " << log_type;
   return std::unique_ptr<LogParser>();
 }
@@ skipping 28 matching lines @@
 }
 
 // Removes direcotry content of |logs_dumps| and |app_logs_dir| (only for the
 // primary profile).
 void CleanUpLeftoverLogs(bool is_primary_profile,
                          const base::FilePath& app_logs_dir,
                          const base::FilePath& logs_dumps) {
   LOG(WARNING) << "Deleting " << app_logs_dir.value();
   LOG(WARNING) << "Deleting " << logs_dumps.value();
 
-  DCHECK(IsRunningOnSequenceThread());
+  AssertCurrentlyOnFileResourceSequence();
   base::DeleteFile(logs_dumps, true);
 
   // App-specific logs are stored in /home/chronos/user/log/apps directory that
   // is shared between all profiles in multi-profile case. We should not
   // nuke it for non-primary profiles.
   if (!is_primary_profile)
     return;
 
   base::DeleteFile(app_logs_dir, true);
 }
@@ skipping 58 matching lines @@
   MaybeStopNetInternalLogging(closure);
 }
 
 void LogPrivateAPI::StopAllWatches(const std::string& extension_id,
                                    const base::Closure& closure) {
   StopNetInternalsWatch(extension_id, closure);
 }
 
 void LogPrivateAPI::RegisterTempFile(const std::string& owner_extension_id,
                                      const base::FilePath& file_path) {
-  if (!IsRunningOnSequenceThread()) {
-    GetSequencedTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LogPrivateAPI::RegisterTempFile,
-                   base::Unretained(this),
-                   owner_extension_id,
-                   file_path));
-    return;
-  }
-
-  log_file_resources_.Add(new FileResource(owner_extension_id, file_path));
+  GetSequencedTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(
+                     [](decltype(&log_file_resources_) log_file_resources,
+                        const std::string& owner_extension_id,
+                        const base::FilePath& file_path) {
+                       log_file_resources->Add(
+                           new FileResource(owner_extension_id, file_path));
+                     },
+                     base::Unretained(&log_file_resources_), owner_extension_id,
+                     file_path));
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<LogPrivateAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<LogPrivateAPI>*
 LogPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
@@ skipping 35 matching lines @@
     std::unique_ptr<Event> event(
         new Event(::extensions::events::LOG_PRIVATE_ON_CAPTURED_EVENTS,
                   ::events::kOnCapturedEvents, std::move(event_args)));
     EventRouter::Get(browser_context_)
         ->DispatchEventToExtension(*ix, std::move(event));
   }
 }
 
 void LogPrivateAPI::CreateTempNetLogFile(const std::string& owner_extension_id,
                                          base::ScopedFILE* file) {
-  DCHECK(IsRunningOnSequenceThread());
+  AssertCurrentlyOnFileResourceSequence();
 
   // Create app-specific subdirectory in session logs folder.
   base::FilePath app_log_dir = GetAppLogDirectory().Append(owner_extension_id);
   if (!base::DirectoryExists(app_log_dir)) {
     if (!base::CreateDirectory(app_log_dir)) {
       LOG(ERROR) << "Could not create dir " << app_log_dir.value();
       return;
     }
   }
 
   base::FilePath file_path = app_log_dir.Append(kLogFileNameBase);
   file_path = logging::GenerateTimestampedName(file_path, base::Time::Now());
   FILE* file_ptr = fopen(file_path.value().c_str(), "w");
   if (file_ptr == nullptr) {
     LOG(ERROR) << "Could not open " << file_path.value();
     return;
   }
 
   RegisterTempFile(owner_extension_id, file_path);

[Reilly Grant (use Gerrit), 2016/09/07 18:00:05]

I believe this change is going to change the semantics of this line because the
new temp file will not be registered synchronously.

[fdoray, 2016/09/07 20:17:42]

Right. Fixed in latest patch set.

   return file->reset(file_ptr);
 }
 
 void LogPrivateAPI::StartObservingNetEvents(
     IOThread* io_thread,
     base::ScopedFILE* file) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!file->get())
     return;
 
@@ skipping 246 matching lines @@
   entry->SetBoolean("isDirectory", false);
   base::ListValue* entry_list = new base::ListValue();
   entry_list->Append(entry);
   response->Set("entries", entry_list);
   response->SetBoolean("multiple", false);
   SetResult(std::move(response));
   SendResponse(succeeded);
 }
 
 }  // namespace extensions