1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// Copyright (c) 2010 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.
//
// Classes for managing the SafeBrowsing interstitial pages.
//
// When a user is about to visit a page the SafeBrowsing system has deemed to
// be malicious, either as malware or a phishing page, we show an interstitial
// page with some options (go back, continue) to give the user a chance to avoid
// the harmful page.
//
// The SafeBrowsingBlockingPage is created by the SafeBrowsingService on the UI
// thread when we've determined that a page is malicious. The operation of the
// blocking page occurs on the UI thread, where it waits for the user to make a
// decision about what to do: either go back or continue on.
//
// The blocking page forwards the result of the user's choice back to the
// SafeBrowsingService so that we can cancel the request for the new page, or
// or allow it to continue.
//
// A web page may contain several resources flagged as malware/phishing. This
// results into more than one interstitial being shown. On the first unsafe
// resource received we show an interstitial. Any subsequent unsafe resource
// notifications while the first interstitial is showing is queued. If the user
// decides to proceed in the first interstitial, we display all queued unsafe
// resources in a new interstitial.
#ifndef CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_BLOCKING_PAGE_H_
#define CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_BLOCKING_PAGE_H_
#pragma once
#include <map>
#include <vector>
#include "chrome/browser/tab_contents/interstitial_page.h"
#include "chrome/browser/safe_browsing/safe_browsing_service.h"
#include "googleurl/src/gurl.h"
class DictionaryValue;
class MessageLoop;
class SafeBrowsingBlockingPageFactory;
class TabContents;
class SafeBrowsingBlockingPage : public InterstitialPage {
public:
virtual ~SafeBrowsingBlockingPage();
// Shows a blocking page warning the user about phishing/malware for a
// specific resource.
// You can call this method several times, if an interstitial is already
// showing, the new one will be queued and displayed if the user decides
// to proceed on the currently showing interstitial.
static void ShowBlockingPage(
SafeBrowsingService* service,
const SafeBrowsingService::UnsafeResource& resource);
// Makes the passed |factory| the factory used to instanciate
// SafeBrowsingBlockingPage objects. Usefull for tests.
static void RegisterFactory(SafeBrowsingBlockingPageFactory* factory) {
factory_ = factory;
}
// InterstitialPage method:
virtual std::string GetHTMLContents();
virtual void Proceed();
virtual void DontProceed();
typedef std::vector<SafeBrowsingService::UnsafeResource> UnsafeResourceList;
protected:
// InterstitialPage method:
virtual void CommandReceived(const std::string& command);
// Don't instanciate this class directly, use ShowBlockingPage instead.
SafeBrowsingBlockingPage(SafeBrowsingService* service,
TabContents* tab_contents,
const UnsafeResourceList& unsafe_resources);
private:
enum BlockingPageEvent {
SHOW,
PROCEED,
DONT_PROCEED,
};
// Fills the passed dictionary with the strings passed to JS Template when
// creating the HTML.
void PopulateMultipleThreatStringDictionary(DictionaryValue* strings);
void PopulateMalwareStringDictionary(DictionaryValue* strings);
void PopulatePhishingStringDictionary(DictionaryValue* strings);
// A helper method used by the Populate methods above used to populate common
// fields.
void PopulateStringDictionary(DictionaryValue* strings,
const std::wstring& title,
const std::wstring& headline,
const std::wstring& description1,
const std::wstring& description2,
const std::wstring& description3);
// Records a user action for this interstitial, using the form
// SBInterstitial[Phishing|Malware|Multiple][Show|Proceed|DontProceed].
void RecordUserAction(BlockingPageEvent event);
// A list of SafeBrowsingService::UnsafeResource for a tab that the user
// should be warned about. They are queued when displaying more than one
// interstitial at a time.
typedef std::map<TabContents*, UnsafeResourceList> UnsafeResourceMap;
static UnsafeResourceMap* GetUnsafeResourcesMap();
// Notifies the SafeBrowsingService on the IO thread whether to proceed or not
// for the |resources|.
static void NotifySafeBrowsingService(SafeBrowsingService* sb_service,
const UnsafeResourceList& resources,
bool proceed);
// Returns true if the passed |unsafe_resources| is for the main page.
static bool IsMainPage(const UnsafeResourceList& unsafe_resources);
private:
friend class SafeBrowsingBlockingPageFactoryImpl;
// For reporting back user actions.
SafeBrowsingService* sb_service_;
MessageLoop* report_loop_;
// Whether the flagged resource is the main page (or a sub-resource is false).
bool is_main_frame_;
// The index of a navigation entry that should be removed when DontProceed()
// is invoked, -1 if not entry should be removed.
int navigation_entry_index_to_remove_;
// The list of unsafe resources this page is warning about.
UnsafeResourceList unsafe_resources_;
// The factory used to instanciate SafeBrowsingBlockingPage objects.
// Usefull for tests, so they can provide their own implementation of
// SafeBrowsingBlockingPage.
static SafeBrowsingBlockingPageFactory* factory_;
DISALLOW_COPY_AND_ASSIGN(SafeBrowsingBlockingPage);
};
// Factory for creating SafeBrowsingBlockingPage. Useful for tests.
class SafeBrowsingBlockingPageFactory {
public:
virtual ~SafeBrowsingBlockingPageFactory() { }
virtual SafeBrowsingBlockingPage* CreateSafeBrowsingPage(
SafeBrowsingService* service,
TabContents* tab_contents,
const SafeBrowsingBlockingPage::UnsafeResourceList& unsafe_resources) = 0;
};
#endif // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_BLOCKING_PAGE_H_
|
