[Offline pages] Add null pointer checks in offline internals code

chrome/browser/ui/webui/offline/offline_internals_ui_message_handler.cc

 // Copyright 2016 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/ui/webui/offline/offline_internals_ui_message_handler.h"
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <vector>
 
@@ skipping 155 matching lines @@
   } else {
     base::ListValue results;
     ResolveJavascriptCallback(base::StringValue(callback_id), results);
   }
 }
 
 void OfflineInternalsUIMessageHandler::HandleSetRecordPageModel(
     const base::ListValue* args) {
   bool should_record;
   CHECK(args->GetBoolean(0, &should_record));
-  offline_page_model_->GetLogger()->SetIsLogging(should_record);
+  if (offline_page_model_)
+    offline_page_model_->GetLogger()->SetIsLogging(should_record);
 }
 
 void OfflineInternalsUIMessageHandler::HandleGetNetworkStatus(
     const base::ListValue* args) {
   const base::Value* callback_id;
   CHECK(args->Get(0, &callback_id));
 
   ResolveJavascriptCallback(
       *callback_id,
       base::StringValue(net::NetworkChangeNotifier::IsOffline() ? "Offline"
                                                                 : "Online"));
 }
 
 void OfflineInternalsUIMessageHandler::HandleSetRecordRequestQueue(
     const base::ListValue* args) {
   bool should_record;
   CHECK(args->GetBoolean(0, &should_record));
-  request_coordinator_->GetLogger()->SetIsLogging(should_record);
+  if (request_coordinator_)
+    request_coordinator_->GetLogger()->SetIsLogging(should_record);
 }
 
 void OfflineInternalsUIMessageHandler::HandleGetLoggingState(
     const base::ListValue* args) {
   AllowJavascript();
   const base::Value* callback_id;
   CHECK(args->Get(0, &callback_id));
 
   base::DictionaryValue result;
   result.SetBoolean("modelIsLogging",
-                    offline_page_model_->GetLogger()->GetIsLogging());
+                    offline_page_model_
+                        ? offline_page_model_->GetLogger()->GetIsLogging()
+                        : false);
   result.SetBoolean("queueIsLogging",
-                    request_coordinator_->GetLogger()->GetIsLogging());
+                    request_coordinator_
+                        ? request_coordinator_->GetLogger()->GetIsLogging()
+                        : false);
   ResolveJavascriptCallback(*callback_id, result);
 }
 
 void OfflineInternalsUIMessageHandler::HandleGetEventLogs(
     const base::ListValue* args) {
   AllowJavascript();
   const base::Value* callback_id;
   CHECK(args->Get(0, &callback_id));
 
   std::vector<std::string> logs;
-  offline_page_model_->GetLogger()->GetLogs(&logs);
-  request_coordinator_->GetLogger()->GetLogs(&logs);
+  if (offline_page_model_)
+    offline_page_model_->GetLogger()->GetLogs(&logs);
+  if (request_coordinator_)
+    request_coordinator_->GetLogger()->GetLogs(&logs);
   std::sort(logs.begin(), logs.end());
 
   base::ListValue result;
   result.AppendStrings(logs);
 
   ResolveJavascriptCallback(*callback_id, result);
 }
 
 void OfflineInternalsUIMessageHandler::HandleAddToRequestQueue(
     const base::ListValue* args) {
   const base::Value* callback_id;
   CHECK(args->Get(0, &callback_id));
 
-  std::string url;
-  CHECK(args->GetString(1, &url));
+  if (request_coordinator_) {
+    std::string url;
+    CHECK(args->GetString(1, &url));
 
-  // To be visible in Downloads UI, these items need a well-formed GUID
-  // and AsyncNamespace in their ClientId.
-  std::ostringstream id_stream;
-  id_stream << base::GenerateGUID();
+    // To be visible in Downloads UI, these items need a well-formed GUID
+    // and AsyncNamespace in their ClientId.
+    std::ostringstream id_stream;
+    id_stream << base::GenerateGUID();
 
-  ResolveJavascriptCallback(
-      *callback_id,
-      base::FundamentalValue(request_coordinator_->SavePageLater(
-          GURL(url), offline_pages::ClientId(offline_pages::kAsyncNamespace,
-                                             id_stream.str()),
-          true)));
+    ResolveJavascriptCallback(
+        *callback_id,
+        base::FundamentalValue(request_coordinator_->SavePageLater(
+            GURL(url), offline_pages::ClientId(offline_pages::kAsyncNamespace,
+                                               id_stream.str()),
+            true)));
+  } else {
+    ResolveJavascriptCallback(*callback_id, base::FundamentalValue(false));
+  }
 }
 
 void OfflineInternalsUIMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "deleteAllPages",
       base::Bind(&OfflineInternalsUIMessageHandler::HandleDeleteAllPages,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback(
       "deleteSelectedPages",
       base::Bind(&OfflineInternalsUIMessageHandler::HandleDeleteSelectedPages,
@@ skipping 33 matching lines @@
 
   // Get the offline page model associated with this web ui.
   Profile* profile = Profile::FromWebUI(web_ui());
   offline_page_model_ =
       offline_pages::OfflinePageModelFactory::GetForBrowserContext(profile);
   request_coordinator_ =
       offline_pages::RequestCoordinatorFactory::GetForBrowserContext(profile);
 }
 
 }  // namespace offline_internals