webkit frameloader

再说一次，当前的frameloader确实复杂呀，代码大概的了解了一片，从load一直到构建dom tree，从网络获得的数据html构建dom tree部分没有仔细看，以后回来看，接下来应该是看render tree生成，因为其主页上有很详细的介绍，所以看起来会比较舒服一些。webkit的网络数据获取部分取决于具体平台的实现，相当的独立，这种方式在跨平台程序编写里面应该是十分常见的。以下是webkit主页上的codepath介绍，也就是我今天所了解的内容：

Tokenizing HTML/XML document

From the moment, piece by piece of an HTML document is obtained from the network, this is what happens:

  [HTML,XML]Tokenizer::write(const SegmentedString& str, bool appendData)
  FrameLoader::write(const char* data, int len, bool flush)
  FrameLoader::addData(const char* bytes, int length)
  FrameLoaderClientQt::committedLoad(DocumentLoader* loader, const char* data, int length)
  FrameLoader::committedLoad(DocumentLoader* loader, const char* data, int length)
  DocumentLoader::commitLoad(const char* data, int length)
  DocumentLoader::receivedData(const char* data, int length)
  FrameLoader::receivedData(const char* data, int length)
  MainResourceLoader::addData(const char* data, int length, bool allAtOnce)
  ResourceLoader::didReceivedData(const char* data, int length, long long received, bool allAtOnce)
  ResourceLoader::didReceiveData(ResourceHandle*, const char* data, int len, long long received)

Get data from network

Shown here for the Qt port, might vary a bit for other ports.

  QNetworkReplyHandler::start()
  QNetworkReplyHandler(ResourceHandle* handle, LoadMode loadMode)
  ResourceHandle::start(Frame* frame)
  ResourceHandle::create(const ResourceRequest& request, ResourceHandleClient* client,
      Frame* frame, bool defersLoading, bool shouldContentSniff, bool mightDownloadFromHandle)
  MainResourceLoader::loadNow(ResourceRequest& r)
  MainResourceLoader::load(const ResourceRequest& r, const SubstituteData& substituteData)
  DocumentLoader::startLoadingMainResource(unsigned long identifier)
  FrameLoader::continueLoadAfterWillSubmitForm(PolicyAction)
  FrameLoader::continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState> formState, bool shouldContinue)
  FrameLoader::callContinueLoadAfterNavigationPolicy(void* argument,
      const ResourceRequest& request, PassRefPtr<FormState> formState, bool shouldContinue)
  PolicyCheck::call(bool shouldContinue)
  FrameLoader::continueAfterNavigationPolicy(PolicyAction policy)
  FrameLoaderClientQt::callPolicyFunction(FramePolicyFunction function, PolicyAction action)
  FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, 
      const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request,
      PassRefPtr<WebCore::FormState>)
  FrameLoader::checkNavigationPolicy(const ResourceRequest& request, DocumentLoader* loader,
      PassRefPtr<FormState> formState, NavigationPolicyDecisionFunction function, void* argument)
  FrameLoader::loadWithDocumentLoader(DocumentLoader* loader, FrameLoadType type, PassRefPtr<FormState> prpFormState)
  FrameLoader::load(DocumentLoader* newDocumentLoader)
  FrameLoader::load(const ResourceRequest& request, const String& frameName, bool lockHistory)
  FrameLoader::load(const ResourceRequest& request, bool lockHistory)
  QWebFrame::load(const QNetworkRequest &req, QNetworkAccessManager::Operation operation,
      const QByteArray &body)
  QWebFrame::load(const QUrl &url)

另外一个很好的参考:http://webkit.org/blog/1188/how-webkit-loads-a-web-page/

这叫做Scala:)

 1 import scala.io.Source
 2
 3 object Hello {
 4   // the length of representing number
 5   def widthOfLength(s: String) = s.length.toString.length
 6
 7   def main(args: Array[String]) {
 8     if (args.length > 0) {
 9       val lines = Source.fromFile(args(0)).getLines.toList
10       val longestLine = lines.reduceLeft(
11         (a, b) => if (a.length > b.length) a else b
12       )
13       val maxWidth = widthOfLength(longestLine)
14       for (line <- lines) {
15         val numSpaces = maxWidth - widthOfLength(line)
16         val padding = " " * numSpaces
17         print(padding + line.length + " ! " + line)
18       }
19     } else
20         Console.err.println("Please enter filename")
21    }
22 }

functional style make you a better geek

"If you come from an imperative background, we believe that learning to program in a functional style will not only make you a better Scala programmer, it will expand your horizons and make you a better programmer in general."

Scala's mutable, immutable object

1.creating, initializing, and using an immutable set:
var jetSet = Set("Boeing", "Airbus")
jetSet += "Lear"
println(jetSet.contains("Cessna"))

2.creating, initializing, and using a mutable set:
import scala.collection.mutable.set
val movieSet = Set("Hitch", "Poltergeist")
movieSet += "Shrek"
println(movieSet)

Because the set in 2 is mutable, there is no need to reassign movieSet,
which is why it can be a val. By contrast, using += with the immutable set
in 1 required reassigning jetSet, which is why it must be a var.

FrameLoader十分臃肿繁杂

这段code做的事情十分多，不是三言两语可以说清楚的。难怪有人想拆分的功能到别的文
件，使得代码的更加简洁，同时增强其readability。比如：
https://bugs.webkit.org/show_bug.cgi?id=36936
这里说了其中一个核心的功能就是在m_documentLoader, m_provisionalDocumentLoader
和m_policyDocumentLoader之中做状态转换。它的实现文件有足足5000多行呢！

Webkit Allocator

Webkit的Allocator使用的是来自google的大神Sanjay Ghemawat的，当然也可以在嵌入式
等系统中根据自己的需要使用custom allocator，webkit在google的allocator加入了类
openCV的allocate/free pair validation，在编译期间做为可选项目。从代码的注释可以
看到端倪：
// Malloc validation is a scheme whereby a tag is attached to an
// allocation which identifies how it was originally allocated.
// This allows us to verify that the freeing operation matches the
// allocation operation. If memory is allocated with operator new[]
// but freed with free or delete, this system would detect that.
// In the implementation here, the tag is an integer prepended to
// the allocation memory which is assigned one of the AllocType
// enumeration values. An alternative implementation of this
// scheme could store the tag somewhere else or ignore it.
// Users of FastMalloc don't need to know or care how this tagging
// is implemented.
再上一小段代码吧，具体在https://bugs.webkit.org/show_bug.cgi?id=20422
// This defines a type which holds an unsigned integer and is the same
// size as the minimally aligned memory allocation.
typedef unsigned long long AllocAlignmentInteger;

namespace Internal {

// Return the AllocType tag associated with the allocated block p.
inline AllocType fastMallocMatchValidationType(const void* p)
{
const AllocAlignmentInteger* type = static_cast(p) - 1;
return static_cast(*type);
}

// Return the address of the AllocType tag associated with the allocated block p.
inline AllocAlignmentInteger* fastMallocMatchValidationValue(void* p)
{
return reinterpret_cast(static_cast(p) - sizeof(AllocAlignmentInteger));
}

// Set the AllocType tag to be associaged with the allocated block p.
inline void setFastMallocMatchValidationType(void* p, AllocType allocType)
{
AllocAlignmentInteger* type = static_cast(p) - 1;
*type = static_cast(allocType);
}

// Handle a detected alloc/free mismatch. By default this calls CRASH().
void fastMallocMatchFailed(void* p);

} // namespace Internal

// This is a higher level function which is used by FastMalloc-using code.
inline void fastMallocMatchValidateMalloc(void* p, Internal::AllocType allocType)
{
if (!p)
return;

Internal::setFastMallocMatchValidationType(p, allocType);
}

// This is a higher level function which is used by FastMalloc-using code.
inline void fastMallocMatchValidateFree(void* p, Internal::AllocType allocType)
{
if (!p)
return;

if (Internal::fastMallocMatchValidationType(p) != allocType)
Internal::fastMallocMatchFailed(p);
Internal::setFastMallocMatchValidationType(p, Internal::AllocTypeMalloc); // Set it to this so that fastFree thinks it's OK.
}

#else

inline void fastMallocMatchValidateMalloc(void*, Internal::AllocType)
{
}

inline void fastMallocMatchValidateFree(void*, Internal::AllocType)
{
}

#endif

About typeStraits

Traits文档boost的写的比较好
http://www.boost.org/doc/libs/1_42_0/libs/type_traits/doc/html/index.html
// GCC's libstdc++ 20070724 and later supports C++ TR1 type_traits in the std namespace.
// VC10 (VS2010) and later support C++ TR1 type_traits in the std::tr1 namespace.
//
// opt::copy
// same semantics as std::copy
// calls memcpy where appropriate.
//

namespace detail{

template
I2 copy_imp(I1 first, I1 last, I2 out, const boost::integral_constant&)
{
while(first != last)
{
*out = *first;
++out;
++first;
}
return out;
}

template
T* copy_imp(const T* first, const T* last, T* out, const boost::true_type&)
{
memcpy(out, first, (last-first)*sizeof(T));
return out+(last-first);
}


}

template
inline I2 copy(I1 first, I1 last, I2 out)
{
//
// We can copy with memcpy if T has a trivial assignment operator,
// and if the iterator arguments are actually pointers (this last
// requirement we detect with overload resolution):
//
typedef typename std::iterator_traits::value_type value_type;
return detail::copy_imp(first, last, out, boost::has_trivial_assign());
}

webkit代码基本目录结构

1.JavaScriptCore，就是其javascript引擎，跨平台的，不同的平台有不同的JIT后端实现。
2.WebCore，包含所有的渲染逻辑，svg支持，图形，网络库等。
3.Webkit，被实际应用的前端，不同的平台有不同的实现，其主要目的就是作为webcore的客户端。
4.Webkit2，类chrome的多进程支持，集成后比chrome的外部方式有明显的优势。
5.JavascriptGlue，为了兼容老的mac平台代码，以后不再进行开发和维护

创新力问题

最近感觉自己少了很多创新力，特别是从春节回来以后，一直感觉自己处在疲倦的状态，
在没有回去前，我看什么都基本没有问题的，能看得个8成以上，而且做也能做出来。当
时，也有跟一些网络课程，比如stanford比较hit的ip或者是一些关于creativity的
但是最近越发难以集中精神了，是不是被一直消磨下去了？希望不是，总之，俺是有点打
算的，现在好像包袱不是很重了，起码在自己心理是这样子的，我或许能够腾出来，而这
一切，我想是需要计划，还有首要的勇气！
其实，有想法的人在世界上不缺乏，缺乏的是那种敢于去实现自己理想的人。
我要做的第一步，肯定是离开，但是，这其中可能需要很大的决心，而且走出第一步后
需要的毅力是难以想象的。
不管怎么样，谁会留在一个对自己的成长无帮助或则阻碍自己发展的地方呢？
plan, plan, plan it!

Property And Synthesize

gratuitousFloat has a dynamic directive—it is supported using direct method implementations;

nameAndAge does not have a dynamic directive, but this is the default value; it is supported using a direct method implementation (since it is read-only, it only requires a getter) with a specified name (nameAndAgeAsString).

@protocol Link
@property id next
@end

@interface MyClass : NSObject {
NSTimeInterval intervalSinceReferenceDate;
CGFloat gratuuitousFloat;
id nextLink;
}

@property (readonly) NSTimeInterval creationTimestamp;
@property (copy) NSString *name;
@property (readonly, getter=nameAndAgeAsString) NSString *nameAndAge;

@implementation MyClass

@synthesize creationTimestamp = intervalSinceReferenceDate, name;
// Synthesizing 'name' is an error in legacy runtimes;
// in modern runtimes, the instance variable is synthesized.

@synthesize next = nextLink;
// Uses instance variable "nextLink" for storage.

@dynamic gratuitousFloat;
// This directive is not strictly necessary.

- (CGFloat)gratuitousFloat {
return gratuitousFloat;
}
- (void)setGratuitousFloat:(CGFloat)aValue {
gratuitousFloat = aValue;
}

- (NSString *)nameAndAgeAsString {
return [NSString stringWithFormat:@"%@ (%fs)", [self name],
[NSDate timeIntervalSinceReferenceDate] - intervalSinceReferenceDate];
}

- (id)init {
if (self = [super init]) {
intervalSinceReferenceDate = [NSDate timeIntervalSinceReferenceDate];
}
return self;
}

- (void)dealloc {
[nextLink release];
[name release];
[super dealloc];
}

@end

about protocols

Protocols declare methods that can be implemented by any class.

To declare methods that others are expected to implement

To declare the interface to an object while concealing its class

To capture similarities among classes that are not hierarchically related

Formal Protocols

@protocol MyProtocol

- (void)requiredMethod;

@optional
- (void)anOptionalMethod;
- (void)anotherOptionalMethod;

@required
- (void)anotherRequiredMethod;

@end

Informal Protocols

@interface NSObject ( MyXMLSupport )
- initFromXMLRepresentation:(NSXMLElement *)XMLElement;
- (NSXMLElement *)XMLRepresentation;
@end

Adopting a Protocol
@interface ClassName : ItsSuperclass < protocol list >
Categories adopt protocols in much the same way:
@interface ClassName ( CategoryName ) < protocol list >

@interface Formatter : NSObject < Formatting, Prettifying >
@end

The Returned Object

Because an init... method might return an object other than the newly allocated receiver, or even return nil, it's important that programs use the value returned by the initialization method, not just that returned by alloc or allocWithZone.

dangerous:
id anObject = [SomeClass alloc];
[anObject init];
[anObject someOtherMessage];
fine:
id anObject = [[SomeClass alloc] init];
[anObject someOtherMessage];
better:
id anObject = [[SomeClass alloc] init];
if ( anObject )
[anObject someOtherMessage];
else
...

cocoa paradigm

A design pattern is a template for a design that solves a general, recurring problem in a particular context.
Cocoa is an object-oriented library of tools that contains many of the objects and methods needed to develop great applications for Mac.
An object consists of both data and methods for manipulating that data. An object is a instance of a class, which means that there is memory allocated for that specific instance of the class. Other objects or external code cannot access the object's data directly, but they request data from the object by sending messages to it.

An Single Object

Model-View-Controller (MVC) is a design pattern that was derived from Smalltalk. It proposes there types of objects in an application, separated by abstract boundaries and communicating with each other across those boundaries

Object relationships in the Model-View-Controller paradigm

Model objects hold data and define the logic that manipulates that data.
A view object represents something visible on the user interface (a window or a button, for example)
Controller Objects Acting as mediators between model objects and view objects in an application are controller objects. Controller objects communicate data back and forth between the model and view objects.
An outlet is an instance variable that identifies an object

Relationships in the target-action paradigm

Create the connection from the object that sends the message to the object that receives the message:

• To make an action connection, create the connection from an element in the user interface, such as a button or a text field, to the custom object you want to send the message to.

• To make an outlet connection, create the connection from the custom object to another object (another custom object or a user interface element) in the application.

一些个人评价

自从还领导以后，室内的管理感觉是在从放羊式逐渐过渡到主动式，但新的leader也不是我
想象那种能激励个人爆发潜力的人，其只求结果，不重视过程的管理模式也让许多人对他微
薄有词，在其眼里，所有的事件都只会对人说很简单，但是自己从来也不会干什么实事，只
在一边做要求，而且做事情没有套路，真怀疑这样子的人究竟有没有管理能力的！
引用 Kevin Kelly, Out of Control里面几句话来讲述我对这里的一些看法：
1.有目标，无计划，有组织，无纪律，无任何的治理概念。
2.讨论者不具备足够基础的背景知识，这就是无效率的会议为何如此众多的原因。
3.进行补丁式管理，任何问题都寄望于通过添加附加流程来小范围解决。
4.管理口号化，流于形式，却不去追究真正的问题根源。
5.主次不分，想到一出是一出，这是一场无序的灾难。